janet_abstract_begin: 1389| 6.91k|void *janet_abstract_begin(const JanetAbstractType *atype, size_t size) { 1390| 6.91k| JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_NONE, 1391| 6.91k| sizeof(JanetAbstractHead) + size); 1392| 6.91k| header->size = size; 1393| 6.91k| header->type = atype; 1394| 6.91k| return (void *) & (header->data); 1395| 6.91k|} janet_abstract_end: 1397| 6.91k|void *janet_abstract_end(void *x) { 1398| 6.91k| janet_gc_settype((void *)(janet_abstract_head(x)), JANET_MEMORY_ABSTRACT); ------------------ | | 679| 6.91k|#define janet_gc_settype(m, t) ((janet_gc_header(m)->flags |= (0xFF & (t)))) | | ------------------ | | | | 673| 6.91k|#define janet_gc_header(mem) ((JanetGCObject *)(mem)) | | ------------------ ------------------ 1399| 6.91k| return x; 1400| 6.91k|} janet_abstract: 1402| 6.91k|void *janet_abstract(const JanetAbstractType *atype, size_t size) { 1403| 6.91k| return janet_abstract_end(janet_abstract_begin(atype, size)); 1404| 6.91k|} janet_array: 1621| 18.4k|JanetArray *janet_array(int32_t capacity) { 1622| 18.4k| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); 1623| 18.4k| janet_array_impl(array, capacity); 1624| 18.4k| return array; 1625| 18.4k|} janet_array_n: 1635| 1.32M|JanetArray *janet_array_n(const Janet *elements, int32_t n) { 1636| 1.32M| JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray)); 1637| 1.32M| array->capacity = n; 1638| 1.32M| array->count = n; 1639| 1.32M| array->data = array_allocate(sizeof(Janet), (size_t) n); 1640| 1.32M| if (!array->data) { ------------------ | Branch (1640:9): [True: 0, False: 1.32M] ------------------ 1641| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 1642| 0| } 1643| 1.32M| safe_memcpy(array->data, elements, sizeof(Janet) * n); 1644| 1.32M| return array; 1645| 1.32M|} janet_array_ensure: 1648| 4.55M|void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) { 1649| 4.55M| Janet *newData; 1650| 4.55M| Janet *old = array->data; 1651| 4.55M| if (capacity <= array->capacity) return; ------------------ | Branch (1651:9): [True: 3.59M, False: 965k] ------------------ 1652| 965k| int64_t new_capacity = ((int64_t) capacity) * growth; 1653| 965k| if (new_capacity > INT32_MAX) new_capacity = INT32_MAX; ------------------ | Branch (1653:9): [True: 0, False: 965k] ------------------ 1654| 965k| capacity = (int32_t) new_capacity; 1655| 965k| newData = janet_realloc(old, capacity * sizeof(Janet)); ------------------ | | 2409| 965k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 1656| 965k| if (NULL == newData) { ------------------ | Branch (1656:9): [True: 0, False: 965k] ------------------ 1657| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 1658| 0| } 1659| 965k| janet_vm.next_collection += (capacity - array->capacity) * sizeof(Janet); 1660| 965k| array->data = newData; 1661| 965k| array->capacity = capacity; 1662| 965k|} janet_array_push: 1679| 467k|void janet_array_push(JanetArray *array, Janet x) { 1680| 467k| if (array->count == INT32_MAX) { ------------------ | Branch (1680:9): [True: 0, False: 467k] ------------------ 1681| 0| janet_panic("array overflow"); 1682| 0| } 1683| 467k| int32_t newcount = array->count + 1; 1684| 467k| janet_array_ensure(array, newcount, 2); 1685| 467k| array->data[array->count] = x; 1686| 467k| array->count = newcount; 1687| 467k|} cfun_array_new_filled: 1734| 2| "`val`, which defaults to nil.") { 1735| 2| janet_arity(argc, 1, 2); 1736| 2| int32_t count = janet_getnat(argv, 0); 1737| 2| Janet x = (argc == 2) ? argv[1] : janet_wrap_nil(); ------------------ | | 831| 2|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1737:15): [True: 0, False: 2] ------------------ 1738| 2| JanetArray *array = janet_array(count); 1739| 12.8k| for (int32_t i = 0; i < count; i++) { ------------------ | Branch (1739:25): [True: 12.8k, False: 2] ------------------ 1740| 12.8k| array->data[i] = x; 1741| 12.8k| } 1742| 2| array->count = count; 1743| 2| return janet_wrap_array(array); ------------------ | | 845| 2|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 2| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1744| 2|} cfun_array_push: 1781| 4.09M| "Returns `arr`.") { 1782| 4.09M| janet_arity(argc, 1, -1); 1783| 4.09M| JanetArray *array = janet_getarray(argv, 0); 1784| 4.09M| if (INT32_MAX - argc + 1 <= array->count) { ------------------ | Branch (1784:9): [True: 0, False: 4.09M] ------------------ 1785| 0| janet_panic("array overflow"); 1786| 0| } 1787| 4.09M| int32_t newcount = array->count - 1 + argc; 1788| 4.09M| janet_array_ensure(array, newcount, 2); 1789| 4.09M| if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet)); ------------------ | Branch (1789:9): [True: 4.09M, False: 0] ------------------ 1790| 4.09M| array->count = newcount; 1791| 4.09M| return argv[0]; 1792| 4.09M|} cfun_array_slice: 1813| 15.1k| "Same as `tuple/slice`, but returns an array.") { 1814| 15.1k| JanetView view = janet_getindexed(argv, 0); 1815| 15.1k| JanetRange range = janet_getslice(argc, argv); 1816| 15.1k| JanetArray *array = janet_array(range.end - range.start); 1817| 15.1k| if (array->data) ------------------ | Branch (1817:9): [True: 15.1k, False: 0] ------------------ 1818| 15.1k| memcpy(array->data, view.items + range.start, sizeof(Janet) * (range.end - range.start)); 1819| 15.1k| array->count = range.end - range.start; 1820| 15.1k| return janet_wrap_array(array); ------------------ | | 845| 15.1k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 15.1k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 15.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 15.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1821| 15.1k|} cfun_array_concat: 1829| 66.2k| "will be appended to `arr` in order. Returns `arr`.") { 1830| 66.2k| int32_t i; 1831| 66.2k| janet_arity(argc, 1, -1); 1832| 66.2k| JanetArray *array = janet_getarray(argv, 0); 1833| 176k| for (i = 1; i < argc; i++) { ------------------ | Branch (1833:17): [True: 109k, False: 66.2k] ------------------ 1834| 109k| switch (janet_type(argv[i])) { ------------------ | | 795| 109k| (isnan((x).number) \ | | 796| 109k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 109k| : JANET_NUMBER) ------------------ | Branch (1834:17): [True: 109k, False: 0] ------------------ 1835| 0| default: ------------------ | Branch (1835:13): [True: 0, False: 109k] ------------------ 1836| 0| janet_array_push(array, argv[i]); 1837| 0| break; 1838| 70.4k| case JANET_ARRAY: ------------------ | Branch (1838:13): [True: 70.4k, False: 39.5k] ------------------ 1839| 109k| case JANET_TUPLE: { ------------------ | Branch (1839:13): [True: 39.5k, False: 70.4k] ------------------ 1840| 109k| int32_t j, len = 0; 1841| 109k| const Janet *vals = NULL; 1842| 109k| janet_indexed_view(argv[i], &vals, &len); 1843| 109k| if (array->data == vals) { ------------------ | Branch (1843:21): [True: 0, False: 109k] ------------------ 1844| 0| int32_t newcount = array->count + len; 1845| 0| janet_array_ensure(array, newcount, 2); 1846| 0| janet_indexed_view(argv[i], &vals, &len); 1847| 0| } 1848| 575k| for (j = 0; j < len; j++) ------------------ | Branch (1848:29): [True: 465k, False: 109k] ------------------ 1849| 465k| janet_array_push(array, vals[j]); 1850| 109k| } 1851| 109k| break; 1852| 109k| } 1853| 109k| } 1854| 66.2k| return janet_wrap_array(array); ------------------ | | 845| 66.2k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 66.2k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 66.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 66.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1855| 66.2k|} janet_lib_array: 1978| 264|void janet_lib_array(JanetTable *env) { 1979| 264| JanetRegExt array_cfuns[] = { 1980| 264| JANET_CORE_REG("array/new", cfun_array_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1981| 264| JANET_CORE_REG("array/weak", cfun_array_weak), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1982| 264| JANET_CORE_REG("array/new-filled", cfun_array_new_filled), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1983| 264| JANET_CORE_REG("array/fill", cfun_array_fill), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1984| 264| JANET_CORE_REG("array/pop", cfun_array_pop), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1985| 264| JANET_CORE_REG("array/peek", cfun_array_peek), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1986| 264| JANET_CORE_REG("array/push", cfun_array_push), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1987| 264| JANET_CORE_REG("array/ensure", cfun_array_ensure), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1988| 264| JANET_CORE_REG("array/slice", cfun_array_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1989| 264| JANET_CORE_REG("array/concat", cfun_array_concat), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1990| 264| JANET_CORE_REG("array/insert", cfun_array_insert), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1991| 264| JANET_CORE_REG("array/remove", cfun_array_remove), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1992| 264| JANET_CORE_REG("array/trim", cfun_array_trim), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1993| 264| JANET_CORE_REG("array/clear", cfun_array_clear), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1994| 264| JANET_CORE_REG("array/join", cfun_array_join), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 1995| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 1996| 264| }; 1997| | janet_core_cfuns_ext(env, NULL, array_cfuns); 1998| 264|} janet_lib_asm: 3143| 264|void janet_lib_asm(JanetTable *env) { 3144| 264| JanetRegExt asm_cfuns[] = { 3145| 264| JANET_CORE_REG("asm", cfun_asm), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3146| 264| JANET_CORE_REG("disasm", cfun_disasm), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3147| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3148| 264| }; 3149| | janet_core_cfuns_ext(env, NULL, asm_cfuns); 3150| 264|} janet_buffer_init: 3211| 89.5k|JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) { 3212| 89.5k| janet_buffer_init_impl(buffer, capacity); 3213| 89.5k| buffer->gc.data.next = NULL; 3214| 89.5k| buffer->gc.flags = JANET_MEM_DISABLED; ------------------ | | 677| 89.5k|#define JANET_MEM_DISABLED 0x200 ------------------ 3215| 89.5k| return buffer; 3216| 89.5k|} janet_buffer_deinit: 3231| 95.2k|void janet_buffer_deinit(JanetBuffer *buffer) { 3232| 95.2k| if (!(buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) { ------------------ | | 1780| 95.2k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3232:9): [True: 95.2k, False: 0] ------------------ 3233| 95.2k| janet_free(buffer->data); ------------------ | | 2415| 95.2k|#define janet_free(X) free((X)) ------------------ 3234| | buffer->data = NULL; 3235| 95.2k| } 3236| 95.2k|} janet_buffer: 3239| 5.72k|JanetBuffer *janet_buffer(int32_t capacity) { 3240| 5.72k| JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer)); 3241| 5.72k| return janet_buffer_init_impl(buffer, capacity); 3242| 5.72k|} janet_buffer_ensure: 3245| 2|void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) { 3246| 2| uint8_t *new_data; 3247| 2| uint8_t *old = buffer->data; 3248| 2| if (capacity <= buffer->capacity) return; ------------------ | Branch (3248:9): [True: 2, False: 0] ------------------ 3249| 0| janet_buffer_can_realloc(buffer); 3250| 0| int64_t big_capacity = ((int64_t) capacity) * growth; 3251| 0| capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity; ------------------ | Branch (3251:16): [True: 0, False: 0] ------------------ 3252| 0| janet_gcpressure(capacity - buffer->capacity); 3253| 0| new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t)); ------------------ | | 2409| 0|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3254| 0| if (NULL == new_data) { ------------------ | Branch (3254:9): [True: 0, False: 0] ------------------ 3255| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3256| 0| } 3257| 0| buffer->data = new_data; 3258| 0| buffer->capacity = capacity; 3259| 0|} janet_buffer_extra: 3275| 6.88M|void janet_buffer_extra(JanetBuffer *buffer, int32_t n) { 3276| | /* Check for buffer overflow */ 3277| 6.88M| if ((int64_t)n + buffer->count > INT32_MAX) { ------------------ | Branch (3277:9): [True: 0, False: 6.88M] ------------------ 3278| 0| janet_panic("buffer overflow"); 3279| 0| } 3280| 6.88M| int32_t new_size = buffer->count + n; 3281| 6.88M| if (new_size > buffer->capacity) { ------------------ | Branch (3281:9): [True: 23.6k, False: 6.86M] ------------------ 3282| 23.6k| janet_buffer_can_realloc(buffer); 3283| 23.6k| int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2); ------------------ | Branch (3283:32): [True: 0, False: 23.6k] ------------------ 3284| 23.6k| uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t)); ------------------ | | 2409| 23.6k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 3285| 23.6k| janet_gcpressure(new_capacity - buffer->capacity); 3286| 23.6k| if (NULL == new_data) { ------------------ | Branch (3286:13): [True: 0, False: 23.6k] ------------------ 3287| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3288| 0| } 3289| 23.6k| buffer->data = new_data; 3290| 23.6k| buffer->capacity = new_capacity; 3291| 23.6k| } 3292| 6.88M|} janet_buffer_push_cstring: 3295| 114k|void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) { 3296| 114k| int32_t len = (int32_t) strlen(cstring); 3297| 114k| janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len); 3298| 114k|} janet_buffer_push_bytes: 3301| 1.06M|void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) { 3302| 1.06M| if (0 == length) return; ------------------ | Branch (3302:9): [True: 214, False: 1.06M] ------------------ 3303| 1.06M| janet_buffer_extra(buffer, length); 3304| 1.06M| memcpy(buffer->data + buffer->count, string, length); 3305| 1.06M| buffer->count += length; 3306| 1.06M|} janet_buffer_push_u8: 3313| 5.70M|void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t byte) { 3314| 5.70M| janet_buffer_extra(buffer, 1); 3315| 5.70M| buffer->data[buffer->count] = byte; 3316| 5.70M| buffer->count++; 3317| 5.70M|} cfun_buffer_chars: 3466| 44.1k| "`buf` as needed. Throws an error if size limit is exceeded.") { 3467| 44.1k| int32_t i; 3468| 44.1k| janet_arity(argc, 1, -1); 3469| 44.1k| JanetBuffer *buffer = janet_getbuffer(argv, 0); 3470| 88.3k| for (i = 1; i < argc; i++) { ------------------ | Branch (3470:17): [True: 44.1k, False: 44.1k] ------------------ 3471| 44.1k| JanetByteView view = janet_getbytes(argv, i); 3472| 44.1k| if (view.bytes == buffer->data) { ------------------ | Branch (3472:13): [True: 0, False: 44.1k] ------------------ 3473| 0| janet_buffer_ensure(buffer, buffer->count + view.len, 2); 3474| 0| view.bytes = buffer->data; 3475| 0| } 3476| 44.1k| janet_buffer_push_bytes(buffer, view.bytes, view.len); 3477| 44.1k| } 3478| 44.1k| return argv[0]; 3479| 44.1k|} cfun_buffer_format: 3808| 44.1k| "buffer `buf`. Returns buf.") { 3809| 44.1k| janet_arity(argc, 2, -1); 3810| 44.1k| JanetBuffer *buffer = janet_getbuffer(argv, 0); 3811| 44.1k| const char *strfrmt = (const char *) janet_getstring(argv, 1); 3812| 44.1k| janet_buffer_format(buffer, strfrmt, 1, argc, argv); 3813| 44.1k| return argv[0]; 3814| 44.1k|} janet_lib_buffer: 3837| 264|void janet_lib_buffer(JanetTable *env) { 3838| 264| JanetRegExt buffer_cfuns[] = { 3839| 264| JANET_CORE_REG("buffer/new", cfun_buffer_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3840| 264| JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3841| 264| JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3842| 264| JANET_CORE_REG("buffer/fill", cfun_buffer_fill), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3843| 264| JANET_CORE_REG("buffer/trim", cfun_buffer_trim), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3844| 264| JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3845| 264| JANET_CORE_REG("buffer/push-word", cfun_buffer_word), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3846| 264| JANET_CORE_REG("buffer/push-string", cfun_buffer_chars), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3847| 264| JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3848| 264| JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3849| 264| JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3850| 264| JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3851| 264| JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3852| 264| JANET_CORE_REG("buffer/push", cfun_buffer_push), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3853| 264| JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3854| 264| JANET_CORE_REG("buffer/popn", cfun_buffer_popn), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3855| 264| JANET_CORE_REG("buffer/clear", cfun_buffer_clear), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3856| 264| JANET_CORE_REG("buffer/slice", cfun_buffer_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3857| 264| JANET_CORE_REG("buffer/bit-set", cfun_buffer_bitset), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3858| 264| JANET_CORE_REG("buffer/bit-clear", cfun_buffer_bitclear), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3859| 264| JANET_CORE_REG("buffer/bit", cfun_buffer_bitget), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3860| 264| JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3861| 264| JANET_CORE_REG("buffer/blit", cfun_buffer_blit), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3862| 264| JANET_CORE_REG("buffer/format", cfun_buffer_format), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3863| 264| JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 3864| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 3865| 264| }; 3866| | janet_core_cfuns_ext(env, NULL, buffer_cfuns); 3867| 264|} janet_bytecode_dead_code: 4714| 161k|void janet_bytecode_dead_code(JanetFuncDef *def) { 4715| 161k| int32_t *pcstack = NULL; 4716| 161k| uint32_t *code = def->bytecode; 4717| 161k| int32_t *codes = (int32_t *)code; 4718| 161k| int32_t len = def->bytecode_length; 4719| 161k| int32_t words = ((len - 1) / 32) + 1; 4720| 161k| uint32_t *visited_bitmap = array_allocate(sizeof(uint32_t), words); 4721| 161k| memset(visited_bitmap, 0, words * sizeof(uint32_t)); 4722| 161k| janet_v_push(pcstack, 0); ------------------ | | 757| 161k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 161k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 161k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 161k, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 161k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 161k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 161k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 4723| 365k| while (janet_v_count(pcstack)) { ------------------ | | 759| 365k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 365k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 365k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:33): [True: 203k, False: 161k] | | | Branch (759:34): [True: 365k, False: 0] | | ------------------ ------------------ 4724| 203k| int32_t pc = janet_v_last(pcstack); ------------------ | | 760| 203k|#define janet_v_last(v) ((v)[janet_v__cnt(v) - 1]) | | ------------------ | | | | 766| 203k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 203k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 4725| 203k| janet_v_pop(pcstack); ------------------ | | 758| 203k|#define janet_v_pop(v) (janet_v_count(v) ? janet_v__cnt(v)-- : 0) | | ------------------ | | | | 759| 203k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | | | ------------------ | | | | | | 766| 203k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | ------------------ | | | | | | | | 764| 203k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (759:33): [True: 203k, False: 0] | | | | | Branch (759:34): [True: 203k, False: 0] | | | | ------------------ | | ------------------ | | #define janet_v_pop(v) (janet_v_count(v) ? janet_v__cnt(v)-- : 0) | | ------------------ | | | | 766| 203k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 203k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 4726| 27.0M| while (pc < len) { ------------------ | Branch (4726:16): [True: 26.9M, False: 172k] ------------------ 4727| 26.9M| int32_t index = pc >> 5; 4728| 26.9M| int32_t mask = ((uint32_t)1) << (pc & 0x1F); 4729| 26.9M| if (visited_bitmap[index] & mask) break; ------------------ | Branch (4729:17): [True: 30.8k, False: 26.8M] ------------------ 4730| 26.8M| visited_bitmap[index] |= mask; 4731| 26.8M| switch (code[pc] & 0x7F) { 4732| 26.6M| default: ------------------ | Branch (4732:17): [True: 26.6M, False: 214k] ------------------ 4733| 26.6M| pc++; 4734| 26.6M| continue; 4735| 11.1k| case JOP_RETURN_NIL: ------------------ | Branch (4735:17): [True: 11.1k, False: 26.8M] ------------------ 4736| 161k| case JOP_RETURN: ------------------ | Branch (4736:17): [True: 150k, False: 26.7M] ------------------ 4737| 161k| case JOP_ERROR: ------------------ | Branch (4737:17): [True: 340, False: 26.8M] ------------------ 4738| 172k| case JOP_TAILCALL: ------------------ | Branch (4738:17): [True: 10.8k, False: 26.8M] ------------------ 4739| 172k| pc = len; 4740| 172k| continue; 4741| 219| case JOP_JUMP: ------------------ | Branch (4741:17): [True: 219, False: 26.8M] ------------------ 4742| 219| janet_v_push(pcstack, pc + (codes[pc] >> 8)); ------------------ | | 757| 219|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 219|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 219|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 219|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 219|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 219|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 219|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 219] | | | | | | | Branch (768:50): [True: 17, False: 202] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 17|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 219|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 219|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 4743| 219| pc = len; 4744| 219| continue; 4745| 0| case JOP_JUMP_IF: ------------------ | Branch (4745:17): [True: 0, False: 26.8M] ------------------ 4746| 219| case JOP_JUMP_IF_NIL: ------------------ | Branch (4746:17): [True: 219, False: 26.8M] ------------------ 4747| 30.9k| case JOP_JUMP_IF_NOT: ------------------ | Branch (4747:17): [True: 30.6k, False: 26.8M] ------------------ 4748| 41.7k| case JOP_JUMP_IF_NOT_NIL: ------------------ | Branch (4748:17): [True: 10.8k, False: 26.8M] ------------------ 4749| 41.7k| janet_v_push(pcstack, pc + (codes[pc] >> 16)); ------------------ | | 757| 41.7k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 41.7k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 41.7k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 41.7k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 41.7k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 41.7k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 41.7k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 41.7k] | | | | | | | Branch (768:50): [True: 11.0k, False: 30.6k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 11.0k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 41.7k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 41.7k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 4750| 41.7k| pc++; 4751| 41.7k| continue; 4752| 26.8M| } 4753| 26.8M| } 4754| 203k| } 4755| 27.0M| for (int32_t pc = 0; pc < len; pc++) { ------------------ | Branch (4755:26): [True: 26.8M, False: 161k] ------------------ 4756| 26.8M| if (!(visited_bitmap[pc >> 5] & (((uint32_t)1) << (pc & 0x1F)))) { ------------------ | Branch (4756:13): [True: 199, False: 26.8M] ------------------ 4757| 199| code[pc] = JOP_NOOP; 4758| 199| } 4759| 26.8M| } 4760| 161k| janet_free(visited_bitmap); ------------------ | | 2415| 161k|#define janet_free(X) free((X)) ------------------ 4761| | janet_v_free(pcstack); ------------------ | | 756| 161k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 161k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 161k, False: 0] | | ------------------ ------------------ 4762| 161k|} janet_bytecode_remove_unused_closures: 4785| 149k|void janet_bytecode_remove_unused_closures(JanetFuncDef *def) { 4786| 149k| if (def->defs_length < 1) return; ------------------ | Branch (4786:9): [True: 69.6k, False: 80.2k] ------------------ 4787| 80.2k| uint32_t *code = def->bytecode; 4788| 80.2k| int32_t words = ((def->defs_length - 1) >> 5) + 1; 4789| 80.2k| janet_assert(words > 0, "bad length"); ------------------ | | 389| 80.2k|#define janet_assert(c, m) do { \ | | 390| 80.2k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 80.2k] | | ------------------ | | 391| 80.2k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 80.2k] | | ------------------ ------------------ 4790| 80.2k| uint32_t *bitset = array_allocate(sizeof(uint32_t), words); 4791| 80.2k| memset(bitset, 0, words * sizeof(uint32_t)); 4792| 1.48M| for (int32_t pc = 0; pc < def->bytecode_length; pc++) { ------------------ | Branch (4792:26): [True: 1.40M, False: 80.2k] ------------------ 4793| 1.40M| uint32_t E = code[pc] >> 16; 4794| 1.40M| switch (code[pc] & 0x7F) { 4795| 1.32M| default: ------------------ | Branch (4795:13): [True: 1.32M, False: 80.0k] ------------------ 4796| 1.32M| continue; 4797| 1.32M| case JOP_CLOSURE: ------------------ | Branch (4797:13): [True: 80.0k, False: 1.32M] ------------------ 4798| 80.0k| bs_set_bit(bitset, E); 4799| 80.0k| continue; 4800| 1.40M| } 4801| 1.40M| } 4802| | 4803| | /* Check if we need to compress closures */ 4804| 80.2k| int remap = 0; 4805| 159k| for (int32_t i = 0; i < def->defs_length; i++) { ------------------ | Branch (4805:25): [True: 80.5k, False: 79.3k] ------------------ 4806| 80.5k| if (!bs_read_bit(bitset, i)) { ------------------ | Branch (4806:13): [True: 865, False: 79.6k] ------------------ 4807| 865| remap = 1; 4808| 865| break; 4809| 865| } 4810| 80.5k| } 4811| | 4812| | /* Remap closures */ 4813| 80.2k| if (remap) { ------------------ | Branch (4813:9): [True: 865, False: 79.3k] ------------------ 4814| 865| uint32_t *def_remaps = array_allocate(sizeof(uint32_t), def->defs_length); 4815| 865| int32_t j = 0; 4816| 2.93k| for (int32_t i = 0; i < def->defs_length; i++) { ------------------ | Branch (4816:29): [True: 2.06k, False: 865] ------------------ 4817| 2.06k| def_remaps[i] = j; 4818| 2.06k| def->defs[j] = def->defs[i]; 4819| 2.06k| if (bs_read_bit(bitset, i)) { ------------------ | Branch (4819:17): [True: 420, False: 1.64k] ------------------ 4820| 420| j++; 4821| 420| } 4822| 2.06k| } 4823| 865| def->defs_length = j; 4824| 13.8k| for (int32_t pc = 0; pc < def->bytecode_length; pc++) { ------------------ | Branch (4824:30): [True: 12.9k, False: 865] ------------------ 4825| 12.9k| uint32_t E = code[pc] >> 16; 4826| 12.9k| switch (code[pc] & 0x7F) { 4827| 12.5k| default: ------------------ | Branch (4827:17): [True: 12.5k, False: 420] ------------------ 4828| 12.5k| continue; 4829| 12.5k| case JOP_CLOSURE: ------------------ | Branch (4829:17): [True: 420, False: 12.5k] ------------------ 4830| 420| code[pc] = (code[pc] & 0xFFFF) | (def_remaps[E] << 16); 4831| 420| continue; 4832| 12.9k| } 4833| 12.9k| } 4834| 865| janet_free(def_remaps); ------------------ | | 2415| 865|#define janet_free(X) free((X)) ------------------ 4835| | 4836| | /* TODO - recalculate closure bitset and do more optimization */ 4837| 865| } 4838| | 4839| 80.2k| janet_free(bitset); ------------------ | | 2415| 80.2k|#define janet_free(X) free((X)) ------------------ 4840| 80.2k|} janet_bytecode_remove_unused_constants: 4843| 149k|void janet_bytecode_remove_unused_constants(JanetFuncDef *def) { 4844| 149k| if (def->constants_length < 1) return; ------------------ | Branch (4844:9): [True: 93.2k, False: 56.6k] ------------------ 4845| 56.6k| uint32_t *code = def->bytecode; 4846| 56.6k| int32_t words = ((def->constants_length - 1) >> 5) + 1; 4847| 56.6k| janet_assert(words > 0, "bad length"); ------------------ | | 389| 56.6k|#define janet_assert(c, m) do { \ | | 390| 56.6k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 56.6k] | | ------------------ | | 391| 56.6k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 56.6k] | | ------------------ ------------------ 4848| 56.6k| uint32_t *bitset = array_allocate(sizeof(uint32_t), words); 4849| 56.6k| memset(bitset, 0, words * sizeof(uint32_t)); 4850| | 4851| | /* Quirk: We rely on the first N constants being the named arguments of a function for warnings 4852| | * while making function calls. Preserve these in the case we have named arguments so we don't get 4853| | * spurious warnings for unused named arguments (or miss warnings!) */ 4854| 56.6k| if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) { ------------------ | | 1107| 56.6k|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (4854:9): [True: 0, False: 56.6k] ------------------ 4855| 0| for (int32_t index = 0; index < def->named_args_count; index++) { ------------------ | Branch (4855:33): [True: 0, False: 0] ------------------ 4856| 0| bs_set_bit(bitset, index); 4857| 0| } 4858| 0| } 4859| | 4860| 2.02M| for (int32_t pc = 0; pc < def->bytecode_length; pc++) { ------------------ | Branch (4860:26): [True: 1.96M, False: 56.6k] ------------------ 4861| 1.96M| uint32_t E = code[pc] >> 16; 4862| 1.96M| switch (code[pc] & 0x7F) { 4863| 1.37M| default: ------------------ | Branch (4863:13): [True: 1.37M, False: 595k] ------------------ 4864| 1.37M| continue; 4865| 1.37M| case JOP_LOAD_CONSTANT: ------------------ | Branch (4865:13): [True: 595k, False: 1.37M] ------------------ 4866| 595k| bs_set_bit(bitset, E); 4867| 595k| continue; 4868| 1.96M| } 4869| 1.96M| } 4870| | 4871| | /* Check if we need to compress constants */ 4872| 56.6k| int remap = 0; 4873| 117k| for (int32_t i = 0; i < def->constants_length; i++) { ------------------ | Branch (4873:25): [True: 60.9k, False: 56.4k] ------------------ 4874| 60.9k| if (!bs_read_bit(bitset, i)) { ------------------ | Branch (4874:13): [True: 164, False: 60.7k] ------------------ 4875| 164| remap = 1; 4876| 164| break; 4877| 164| } 4878| 60.9k| } 4879| | 4880| | /* Remap constants */ 4881| 56.6k| if (remap) { ------------------ | Branch (4881:9): [True: 164, False: 56.4k] ------------------ 4882| 164| uint32_t *constant_remaps = array_allocate(sizeof(uint32_t), def->constants_length); 4883| 164| int32_t j = 0; 4884| 626| for (int32_t i = 0; i < def->constants_length; i++) { ------------------ | Branch (4884:29): [True: 462, False: 164] ------------------ 4885| 462| constant_remaps[i] = j; 4886| 462| def->constants[j] = def->constants[i]; 4887| 462| if (bs_read_bit(bitset, i)) { ------------------ | Branch (4887:17): [True: 149, False: 313] ------------------ 4888| 149| j++; 4889| 149| } 4890| 462| } 4891| 164| def->constants_length = j; 4892| 1.53k| for (int32_t pc = 0; pc < def->bytecode_length; pc++) { ------------------ | Branch (4892:30): [True: 1.36k, False: 164] ------------------ 4893| 1.36k| uint32_t E = code[pc] >> 16; 4894| 1.36k| switch (code[pc] & 0x7F) { 4895| 1.15k| default: ------------------ | Branch (4895:17): [True: 1.15k, False: 212] ------------------ 4896| 1.15k| continue; 4897| 1.15k| case JOP_LOAD_CONSTANT: ------------------ | Branch (4897:17): [True: 212, False: 1.15k] ------------------ 4898| 212| code[pc] = (code[pc] & 0xFFFF) | (constant_remaps[E] << 16); 4899| 212| continue; 4900| 1.36k| } 4901| 1.36k| } 4902| 164| janet_free(constant_remaps); ------------------ | | 2415| 164|#define janet_free(X) free((X)) ------------------ 4903| 164| } 4904| | 4905| 56.6k| janet_free(bitset); ------------------ | | 2415| 56.6k|#define janet_free(X) free((X)) ------------------ 4906| 56.6k|} janet_bytecode_remove_noops: 4910| 161k|void janet_bytecode_remove_noops(JanetFuncDef *def) { 4911| | 4912| | /* Get an instruction rewrite map so we can rewrite jumps */ 4913| 161k| uint32_t *pc_map = janet_smalloc(sizeof(uint32_t) * (1 + def->bytecode_length)); 4914| 161k| uint32_t new_bytecode_length = 0; 4915| 27.0M| for (int32_t i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (4915:25): [True: 26.8M, False: 161k] ------------------ 4916| 26.8M| uint32_t instr = def->bytecode[i]; 4917| 26.8M| uint32_t opcode = instr & 0x7F; 4918| 26.8M| pc_map[i] = new_bytecode_length; 4919| 26.8M| if (opcode != JOP_NOOP) { ------------------ | Branch (4919:13): [True: 25.0M, False: 1.85M] ------------------ 4920| 25.0M| new_bytecode_length++; 4921| 25.0M| } 4922| 26.8M| } 4923| 161k| pc_map[def->bytecode_length] = new_bytecode_length; 4924| | 4925| | /* Linear scan rewrite bytecode and sourcemap. Also fix jumps. */ 4926| 161k| int32_t j = 0; 4927| 27.0M| for (int32_t i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (4927:25): [True: 26.8M, False: 161k] ------------------ 4928| 26.8M| uint32_t instr = def->bytecode[i]; 4929| 26.8M| uint32_t opcode = instr & 0x7F; 4930| 26.8M| int32_t old_jump_target = 0; 4931| 26.8M| int32_t new_jump_target = 0; 4932| 26.8M| switch (opcode) { 4933| 1.85M| case JOP_NOOP: ------------------ | Branch (4933:13): [True: 1.85M, False: 25.0M] ------------------ 4934| 1.85M| continue; 4935| 219| case JOP_JUMP: ------------------ | Branch (4935:13): [True: 219, False: 26.8M] ------------------ 4936| | /* relative pc is in DS field of instruction */ 4937| 219| old_jump_target = i + (((int32_t)instr) >> 8); 4938| 219| janet_assert(old_jump_target >= 0, "bounds"); ------------------ | | 389| 219|#define janet_assert(c, m) do { \ | | 390| 219| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 219] | | ------------------ | | 391| 219|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 219] | | ------------------ ------------------ 4939| 219| janet_assert(old_jump_target < def->bytecode_length, "bounds"); ------------------ | | 389| 219|#define janet_assert(c, m) do { \ | | 390| 219| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 219] | | ------------------ | | 391| 219|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 219] | | ------------------ ------------------ 4940| 219| new_jump_target = pc_map[old_jump_target]; 4941| 219| instr += (uint32_t)(new_jump_target - old_jump_target + (i - j)) << 8; 4942| 219| break; 4943| 0| case JOP_JUMP_IF: ------------------ | Branch (4943:13): [True: 0, False: 26.8M] ------------------ 4944| 219| case JOP_JUMP_IF_NIL: ------------------ | Branch (4944:13): [True: 219, False: 26.8M] ------------------ 4945| 30.9k| case JOP_JUMP_IF_NOT: ------------------ | Branch (4945:13): [True: 30.6k, False: 26.8M] ------------------ 4946| 41.7k| case JOP_JUMP_IF_NOT_NIL: ------------------ | Branch (4946:13): [True: 10.8k, False: 26.8M] ------------------ 4947| | /* relative pc is in ES field of instruction */ 4948| 41.7k| old_jump_target = i + (((int32_t)instr) >> 16); 4949| 41.7k| janet_assert(old_jump_target >= 0, "bounds"); ------------------ | | 389| 41.7k|#define janet_assert(c, m) do { \ | | 390| 41.7k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 41.7k] | | ------------------ | | 391| 41.7k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 41.7k] | | ------------------ ------------------ 4950| 41.7k| janet_assert(old_jump_target < def->bytecode_length, "bounds"); ------------------ | | 389| 41.7k|#define janet_assert(c, m) do { \ | | 390| 41.7k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 41.7k] | | ------------------ | | 391| 41.7k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 41.7k] | | ------------------ ------------------ 4951| 41.7k| new_jump_target = pc_map[old_jump_target]; 4952| 41.7k| instr += (uint32_t)(new_jump_target - old_jump_target + (i - j)) << 16; 4953| 41.7k| break; 4954| 24.9M| default: ------------------ | Branch (4954:13): [True: 24.9M, False: 1.89M] ------------------ 4955| 24.9M| break; 4956| 26.8M| } 4957| 25.0M| def->bytecode[j] = instr; 4958| 25.0M| if (def->sourcemap != NULL) { ------------------ | Branch (4958:13): [True: 25.0M, False: 0] ------------------ 4959| 25.0M| def->sourcemap[j] = def->sourcemap[i]; 4960| 25.0M| } 4961| 25.0M| j++; 4962| 25.0M| } 4963| | 4964| | /* Rewrite symbolmap */ 4965| 161k| rewrite_symbolmap(def, pc_map); 4966| | 4967| 161k| def->bytecode_length = new_bytecode_length; 4968| 161k| def->bytecode = janet_realloc(def->bytecode, def->bytecode_length * sizeof(uint32_t)); ------------------ | | 2409| 161k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 4969| 161k| janet_sfree(pc_map); 4970| 161k|} janet_bytecode_jump_threading: 4974| 161k|void janet_bytecode_jump_threading(JanetFuncDef *def) { 4975| 161k| int32_t blen = def->bytecode_length; 4976| 161k| uint32_t *code = def->bytecode; 4977| 161k| int32_t *codes = (int32_t *)code; 4978| 161k| int recur = 1; 4979| 323k| while (recur) { ------------------ | Branch (4979:12): [True: 161k, False: 161k] ------------------ 4980| 161k| recur = 0; 4981| 27.0M| for (int32_t i = 0; i < blen; i++) { ------------------ | Branch (4981:29): [True: 26.8M, False: 161k] ------------------ 4982| 26.8M| int32_t target; 4983| 26.8M| int is_branch = 0; 4984| 26.8M| switch (code[i] & 0x7F) { 4985| 21.2M| default: ------------------ | Branch (4985:17): [True: 21.2M, False: 5.60M] ------------------ 4986| 21.2M| continue; 4987| 21.2M| case JOP_MOVE_NEAR: ------------------ | Branch (4987:17): [True: 2.71M, False: 24.1M] ------------------ 4988| 5.56M| case JOP_MOVE_FAR: ------------------ | Branch (4988:17): [True: 2.84M, False: 24.0M] ------------------ 4989| 5.56M| if (((codes[i] >> 8) & 0xFF) == (codes[i] >> 16)) { ------------------ | Branch (4989:25): [True: 0, False: 5.56M] ------------------ 4990| | /* Not really jump threading, but an easy optimization */ 4991| 0| code[i] = JOP_NOOP; 4992| 0| } 4993| 5.56M| continue; 4994| 219| case JOP_JUMP: ------------------ | Branch (4994:17): [True: 219, False: 26.8M] ------------------ 4995| 219| target = i + (codes[i] >> 8); 4996| 219| break; 4997| 0| case JOP_JUMP_IF: ------------------ | Branch (4997:17): [True: 0, False: 26.8M] ------------------ 4998| 30.6k| case JOP_JUMP_IF_NOT: ------------------ | Branch (4998:17): [True: 30.6k, False: 26.8M] ------------------ 4999| 30.9k| case JOP_JUMP_IF_NIL: ------------------ | Branch (4999:17): [True: 219, False: 26.8M] ------------------ 5000| 41.7k| case JOP_JUMP_IF_NOT_NIL: ------------------ | Branch (5000:17): [True: 10.8k, False: 26.8M] ------------------ 5001| 41.7k| is_branch = 1; 5002| 41.7k| target = i + (codes[i] >> 16); 5003| 41.7k| break; 5004| 26.8M| } 5005| 41.9k| if (target == i) continue; /* infinite loop */ ------------------ | Branch (5005:17): [True: 0, False: 41.9k] ------------------ 5006| 41.9k| if (target == i + 1) { ------------------ | Branch (5006:17): [True: 0, False: 41.9k] ------------------ 5007| 0| code[i] = JOP_NOOP; 5008| 0| recur = 1; 5009| 0| continue; 5010| 0| } 5011| 41.9k| while ((code[target] & 0x7F) == JOP_NOOP) { /* Skip noops */ ------------------ | Branch (5011:20): [True: 0, False: 41.9k] ------------------ 5012| 0| target++; 5013| 0| } 5014| 41.9k| if ((code[target] & 0x7F) == JOP_RETURN_NIL && !is_branch) { ------------------ | Branch (5014:17): [True: 92, False: 41.8k] | Branch (5014:60): [True: 0, False: 92] ------------------ 5015| 0| code[i] = JOP_RETURN_NIL; 5016| 0| recur = 1; 5017| 0| continue; 5018| 0| } 5019| | /* update target */ 5020| 41.9k| if ((code[target] & 0x7F) == JOP_JUMP) { ------------------ | Branch (5020:17): [True: 0, False: 41.9k] ------------------ 5021| 0| target += (codes[target] >> 8); 5022| 0| } 5023| 41.9k| uint32_t newcode; 5024| 41.9k| if (is_branch) { ------------------ | Branch (5024:17): [True: 41.7k, False: 219] ------------------ 5025| 41.7k| newcode = (code[i] & 0xFFFF) | ((uint32_t)(target - i) << 16); 5026| 41.7k| } else { 5027| 219| newcode = (code[i] & 0xFF) | ((uint32_t)(target - i) << 8); 5028| 219| } 5029| 41.9k| if (newcode != code[i]) recur = 1; ------------------ | Branch (5029:17): [True: 0, False: 41.9k] ------------------ 5030| 41.9k| code[i] = newcode; 5031| 41.9k| } 5032| 161k| } 5033| 161k|} janet_bytecode_movopt_full: 5275| 161k|void janet_bytecode_movopt_full(JanetFuncDef *def, BytecodeBB *blocks, int32_t nblocks) { 5276| | 5277| | /* Allocate nblocks bitmaps */ 5278| 161k| int32_t wordlen = ((def->slotcount - 1) >> 5) + 1; 5279| 161k| janet_assert(wordlen > 0, "bad len"); ------------------ | | 389| 161k|#define janet_assert(c, m) do { \ | | 390| 161k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 161k] | | ------------------ | | 391| 161k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 161k] | | ------------------ ------------------ 5280| 161k| uint32_t **bitsets = array_allocate(sizeof(uint32_t *), nblocks); 5281| 376k| for (int32_t block_i = 0; block_i < nblocks; block_i++) { ------------------ | Branch (5281:31): [True: 215k, False: 161k] ------------------ 5282| 215k| bitsets[block_i] = array_allocate(sizeof(uint32_t), wordlen); 5283| 215k| memset(bitsets[block_i], 0, wordlen * sizeof(uint32_t)); 5284| 215k| } 5285| | 5286| | /* Find all local block inputs */ 5287| 376k| for (int32_t block_i = 0; block_i < nblocks; block_i++) { ------------------ | Branch (5287:31): [True: 215k, False: 161k] ------------------ 5288| 215k| janet_bytecode_movopt_basic_block(def, blocks[block_i], bitsets[block_i], 1); 5289| 215k| } 5290| | 5291| | /* Propagate inputs to predecessors */ 5292| 161k| int recur = 1; 5293| 323k| while (recur) { ------------------ | Branch (5293:12): [True: 162k, False: 161k] ------------------ 5294| 162k| recur = 0; 5295| 1.12M| for (int32_t block_i = 0; block_i < nblocks; block_i++) { ------------------ | Branch (5295:35): [True: 965k, False: 162k] ------------------ 5296| 2.89M| for (int j = 0; j < 2; j++) { ------------------ | Branch (5296:29): [True: 1.93M, False: 965k] ------------------ 5297| 1.93M| int32_t block_next = blocks[block_i].next[j]; 5298| 1.93M| if (block_next != -1) { ------------------ | Branch (5298:21): [True: 1.56M, False: 370k] ------------------ 5299| 5.11M| for (int32_t i = 0; i < wordlen; i++) { ------------------ | Branch (5299:41): [True: 3.55M, False: 1.56M] ------------------ 5300| 3.55M| uint32_t before = bitsets[block_i][i]; 5301| 3.55M| bitsets[block_i][i] |= bitsets[block_next][i]; 5302| 3.55M| if (before != bitsets[block_i][i]) recur = 1; ------------------ | Branch (5302:29): [True: 93.7k, False: 3.45M] ------------------ 5303| 3.55M| } 5304| 1.56M| } 5305| 1.93M| } 5306| 965k| } 5307| 162k| } 5308| | 5309| | /* Remove extra writes */ 5310| 376k| for (int32_t block_i = 0; block_i < nblocks; block_i++) { ------------------ | Branch (5310:31): [True: 215k, False: 161k] ------------------ 5311| 215k| janet_bytecode_movopt_basic_block(def, blocks[block_i], bitsets[block_i], 0); 5312| 215k| } 5313| | 5314| | /* Cleanup */ 5315| 376k| for (int32_t block_i = 0; block_i < nblocks; block_i++) { ------------------ | Branch (5315:31): [True: 215k, False: 161k] ------------------ 5316| 215k| janet_free(bitsets[block_i]); ------------------ | | 2415| 215k|#define janet_free(X) free((X)) ------------------ 5317| 215k| } 5318| 161k| janet_free(bitsets); ------------------ | | 2415| 161k|#define janet_free(X) free((X)) ------------------ 5319| 161k|} janet_bytecode_compact_slots: 5322| 149k|void janet_bytecode_compact_slots(JanetFuncDef *def) { 5323| | /* TODO - we would need to be somewhat careful in that case. */ 5324| 149k| if (def->slotcount > 256) return; ------------------ | Branch (5324:9): [True: 280, False: 149k] ------------------ 5325| | /* Remap: old slot -> new slot */ 5326| | /* Invert: new slot -> old slot */ 5327| 149k| int32_t *remap = array_allocate(sizeof(int32_t), def->slotcount * 2); 5328| 149k| int32_t *invert = remap + def->slotcount; 5329| 149k| uint32_t *code = def->bytecode; 5330| 149k| int32_t len = def->bytecode_length; 5331| 149k| int32_t next_slot = def->arity; 5332| 149k| int32_t greatest = 0; 5333| 513k| for (int32_t i = 0; i < def->slotcount * 2; i++) remap[i] = -1; ------------------ | Branch (5333:25): [True: 364k, False: 149k] ------------------ 5334| | /* Pin closure slots for now */ 5335| 149k| if (def->closure_bitset) { ------------------ | Branch (5335:9): [True: 453, False: 149k] ------------------ 5336| 17.7k| for (int32_t i = 0; i < def->slotcount; i++) { ------------------ | Branch (5336:29): [True: 17.2k, False: 453] ------------------ 5337| 17.2k| if (bs_read_bit(def->closure_bitset, i)) { ------------------ | Branch (5337:17): [True: 920, False: 16.3k] ------------------ 5338| 920| remap[i] = i; 5339| 920| invert[i] = i; 5340| 920| greatest = i; 5341| 920| } 5342| 17.2k| } 5343| 453| } 5344| | /* Pin arguments - TODO slots for unused arguments could be reused */ 5345| 153k| for (int32_t i = 0; i < def->arity && i < def->slotcount; i++) { ------------------ | Branch (5345:25): [True: 3.93k, False: 149k] | Branch (5345:43): [True: 3.93k, False: 0] ------------------ 5346| 3.93k| remap[i] = i; 5347| 3.93k| invert[i] = i; 5348| 3.93k| if (i > greatest) greatest = i; ------------------ | Branch (5348:13): [True: 1.79k, False: 2.14k] ------------------ 5349| 3.93k| } 5350| 149k| if (def->flags & (JANET_FUNCDEF_FLAG_VARARG | JANET_FUNCDEF_FLAG_NAMEDARGS | JANET_FUNCDEF_FLAG_STRUCTARG)) { ------------------ | | 1097| 149k|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ if (def->flags & (JANET_FUNCDEF_FLAG_VARARG | JANET_FUNCDEF_FLAG_NAMEDARGS | JANET_FUNCDEF_FLAG_STRUCTARG)) { ------------------ | | 1107| 149k|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ if (def->flags & (JANET_FUNCDEF_FLAG_VARARG | JANET_FUNCDEF_FLAG_NAMEDARGS | JANET_FUNCDEF_FLAG_STRUCTARG)) { ------------------ | | 1105| 149k|#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 ------------------ | Branch (5350:9): [True: 3, False: 149k] ------------------ 5351| 3| remap[def->arity] = def->arity; 5352| 3| invert[def->arity] = def->arity; 5353| 3| next_slot++; 5354| 3| } 5355| | /* Rename 8 bit slots first, then larger slots */ 5356| 634k| for (int32_t pc = 0; pc < len; pc++) { ------------------ | Branch (5356:26): [True: 485k, False: 149k] ------------------ 5357| 485k| enum JanetInstructionType itype = janet_instructions[code[pc] & 0x7F]; 5358| 485k| int nslots = 0; 5359| 485k| uint32_t slots[3]; 5360| | /* rewrite slots. For now, assume adding slot delta will not overflow any slot indices */ 5361| 485k| switch (itype) { ------------------ | Branch (5361:17): [True: 485k, False: 0] ------------------ 5362| 604| case JINT_0: ------------------ | Branch (5362:13): [True: 604, False: 484k] ------------------ 5363| 661| case JINT_L: ------------------ | Branch (5363:13): [True: 57, False: 485k] ------------------ 5364| 661| continue; 5365| 155k| case JINT_S: ------------------ | Branch (5365:13): [True: 155k, False: 329k] ------------------ 5366| 155k| nslots = 1; 5367| 155k| slots[0] = (code[pc] >> 8) & 0xFFFFFFU; 5368| 155k| break; 5369| 5.29k| case JINT_SES: ------------------ | Branch (5369:13): [True: 5.29k, False: 479k] ------------------ 5370| 15.5k| case JINT_SI: ------------------ | Branch (5370:13): [True: 10.2k, False: 474k] ------------------ 5371| 15.5k| case JINT_SU: ------------------ | Branch (5371:13): [True: 0, False: 485k] ------------------ 5372| 15.5k| case JINT_ST: ------------------ | Branch (5372:13): [True: 0, False: 485k] ------------------ 5373| 46.6k| case JINT_SL: ------------------ | Branch (5373:13): [True: 31.0k, False: 454k] ------------------ 5374| 126k| case JINT_SD: ------------------ | Branch (5374:13): [True: 79.7k, False: 405k] ------------------ 5375| 266k| case JINT_SC: ------------------ | Branch (5375:13): [True: 140k, False: 344k] ------------------ 5376| 266k| nslots = 1; 5377| 266k| slots[0] = (code[pc] >> 8) & 0xFFU; 5378| 266k| break; 5379| 4.88k| case JINT_SS: ------------------ | Branch (5379:13): [True: 4.88k, False: 480k] ------------------ 5380| 4.88k| nslots = 2; 5381| 4.88k| slots[0] = (code[pc] >> 8) & 0xFFU; 5382| 4.88k| slots[1] = (code[pc] >> 16) & 0xFFFFU; 5383| 4.88k| break; 5384| 760| case JINT_SSI: ------------------ | Branch (5384:13): [True: 760, False: 484k] ------------------ 5385| 10.2k| case JINT_SSU: ------------------ | Branch (5385:13): [True: 9.44k, False: 475k] ------------------ 5386| 10.2k| nslots = 2; 5387| 10.2k| slots[0] = (code[pc] >> 8) & 0xFFU; 5388| 10.2k| slots[1] = (code[pc] >> 16) & 0xFFU; 5389| 10.2k| break; 5390| 47.3k| case JINT_SSS: ------------------ | Branch (5390:13): [True: 47.3k, False: 437k] ------------------ 5391| 47.3k| nslots = 3; 5392| 47.3k| slots[0] = (code[pc] >> 8) & 0xFFU; 5393| 47.3k| slots[1] = (code[pc] >> 16) & 0xFFU; 5394| 47.3k| slots[2] = code[pc] >> 24; 5395| 47.3k| break; 5396| 485k| } 5397| | /* Find new slots */ 5398| 1.07M| for (int i = 0; i < nslots; i++) { ------------------ | Branch (5398:25): [True: 594k, False: 484k] ------------------ 5399| 594k| if (remap[slots[i]] == -1) { ------------------ | Branch (5399:17): [True: 158k, False: 436k] ------------------ 5400| 158k| while (invert[next_slot] != -1) next_slot++; ------------------ | Branch (5400:24): [True: 329, False: 158k] ------------------ 5401| 158k| remap[slots[i]] = next_slot; 5402| 158k| invert[next_slot] = slots[i]; 5403| 158k| next_slot++; 5404| 158k| } 5405| 594k| slots[i] = remap[slots[i]]; 5406| 594k| } 5407| | /* Now rewrite */ 5408| 484k| switch (itype) { ------------------ | Branch (5408:17): [True: 484k, False: 0] ------------------ 5409| 0| case JINT_0: ------------------ | Branch (5409:13): [True: 0, False: 484k] ------------------ 5410| 0| case JINT_L: ------------------ | Branch (5410:13): [True: 0, False: 484k] ------------------ 5411| 0| continue; 5412| 155k| case JINT_S: ------------------ | Branch (5412:13): [True: 155k, False: 329k] ------------------ 5413| 155k| code[pc] = (code[pc] & 0xFFU) | (slots[0] << 8); 5414| 155k| break; 5415| 5.29k| case JINT_SES: ------------------ | Branch (5415:13): [True: 5.29k, False: 479k] ------------------ 5416| 15.5k| case JINT_SI: ------------------ | Branch (5416:13): [True: 10.2k, False: 474k] ------------------ 5417| 15.5k| case JINT_SU: ------------------ | Branch (5417:13): [True: 0, False: 484k] ------------------ 5418| 15.5k| case JINT_ST: ------------------ | Branch (5418:13): [True: 0, False: 484k] ------------------ 5419| 46.6k| case JINT_SL: ------------------ | Branch (5419:13): [True: 31.0k, False: 453k] ------------------ 5420| 126k| case JINT_SD: ------------------ | Branch (5420:13): [True: 79.7k, False: 404k] ------------------ 5421| 266k| case JINT_SC: ------------------ | Branch (5421:13): [True: 140k, False: 344k] ------------------ 5422| 266k| code[pc] = (code[pc] & 0xFFFF00FFU) | ((slots[0] & 0xFF) << 8); 5423| 266k| break; 5424| 4.88k| case JINT_SS: ------------------ | Branch (5424:13): [True: 4.88k, False: 479k] ------------------ 5425| 4.88k| code[pc] = (code[pc] & 0xFFU) | ((slots[0] & 0xFF) << 8) | (slots[1] << 16); 5426| 4.88k| break; 5427| 760| case JINT_SSI: ------------------ | Branch (5427:13): [True: 760, False: 483k] ------------------ 5428| 10.2k| case JINT_SSU: ------------------ | Branch (5428:13): [True: 9.44k, False: 475k] ------------------ 5429| 10.2k| code[pc] = (code[pc] & 0xFF0000FFU) | ((slots[0] & 0xFF) << 8) | ((slots[1] & 0xFF) << 16); 5430| 10.2k| break; 5431| 47.3k| case JINT_SSS: ------------------ | Branch (5431:13): [True: 47.3k, False: 437k] ------------------ 5432| 47.3k| code[pc] = (code[pc] & 0xFFU) | ((slots[0] & 0xFF) << 8) | ((slots[1] & 0xFF) << 16) | (slots[2] << 24); 5433| 47.3k| break; 5434| 484k| } 5435| 484k| } 5436| | /* Fix symbol mappings */ 5437| 149k| int32_t smout = 0; 5438| 2.32M| for (int32_t i = 0; i < def->symbolmap_length; i++) { ------------------ | Branch (5438:25): [True: 2.17M, False: 149k] ------------------ 5439| 2.17M| if (def->symbolmap[i].birth_pc == UINT32_MAX) { ------------------ | Branch (5439:13): [True: 2.14M, False: 23.9k] ------------------ 5440| 2.14M| smout++; 5441| 2.14M| continue; /* upvalue */ 5442| 2.14M| } 5443| 23.9k| JanetSymbolMap sm = def->symbolmap[i]; 5444| 23.9k| uint32_t old_slot = sm.slot_index; 5445| 23.9k| if (remap[old_slot] != -1) { /* If not remapped, drop! */ ------------------ | Branch (5445:13): [True: 5.05k, False: 18.8k] ------------------ 5446| 5.05k| sm.slot_index = (uint32_t) remap[old_slot]; 5447| 5.05k| def->symbolmap[smout++] = sm; 5448| 5.05k| } 5449| 23.9k| } 5450| 149k| def->symbolmap_length = smout; 5451| 149k| if (greatest + 1 > next_slot) next_slot = greatest + 1; ------------------ | Branch (5451:9): [True: 362, False: 149k] ------------------ 5452| 149k| def->slotcount = next_slot; 5453| 149k| janet_free(remap); ------------------ | | 2415| 149k|#define janet_free(X) free((X)) ------------------ 5454| 149k|} janet_bytecode_optimize: 5596| 149k|void janet_bytecode_optimize(JanetFuncDef *def, int32_t level) { 5597| 149k| int32_t delta; 5598| |#ifdef JANET_DEBUG 5599| | int result = janet_verify(def); 5600| | if (result != 0) { 5601| | for (int32_t i = 0; i < def->bytecode_length; i++) { 5602| | janet_eprintf("%4d: %Q\n", i, janet_asm_decode_instruction(def->bytecode[i])); 5603| | } 5604| | } 5605| | janet_assert(result == 0, "input bytecode bad"); 5606| |#endif 5607| 149k| if (level >= 0) { ------------------ | Branch (5607:9): [True: 149k, False: 0] ------------------ 5608| 161k| do { /* Fixpoint for instruction removal */ 5609| 161k| int32_t before = def->bytecode_length; 5610| 161k| janet_bytecode_jump_threading(def); 5611| 161k| { 5612| 161k| int32_t nblocks = 0; 5613| 161k| BytecodeBB *basic_blocks = janet_bytecode_basic_blocks(def, &nblocks); 5614| 161k| janet_assert(nblocks > 0, "no blocks"); ------------------ | | 389| 161k|#define janet_assert(c, m) do { \ | | 390| 161k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 161k] | | ------------------ | | 391| 161k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 161k] | | ------------------ ------------------ 5615| 161k| if (level >= 1) { ------------------ | Branch (5615:21): [True: 0, False: 161k] ------------------ 5616| | /* TODO - allow limited value numbering at optimize = 0. 5617| | * Constant folding can currently remove named slots which can break debug info */ 5618| 0| janet_bytecode_local_value_numbering(def, basic_blocks, nblocks); 5619| 0| } 5620| | /* This will currently also break debug info, although less severely than 5621| | * value numbering. At optimize=0, we should pin all named slots but allow 5622| | * constant propogation for anonymous intermediate computations */ 5623| 161k| janet_bytecode_movopt_full(def, basic_blocks, nblocks); 5624| 161k| janet_free(basic_blocks); ------------------ | | 2415| 161k|#define janet_free(X) free((X)) ------------------ 5625| 161k| } 5626| 0| janet_bytecode_dead_code(def); 5627| 161k| janet_bytecode_remove_noops(def); 5628| 161k| delta = def->bytecode_length - before; 5629| |#ifdef JANET_BOOTSTRAP 5630| | total_optimize_fixpoint_loops++; 5631| |#endif 5632| 161k| } while (delta < 0); ------------------ | Branch (5632:18): [True: 11.7k, False: 149k] ------------------ 5633| 149k| janet_bytecode_remove_unused_constants(def); 5634| 149k| janet_bytecode_remove_unused_closures(def); 5635| 149k| janet_bytecode_compact_slots(def); 5636| 149k| } 5637| |#ifdef JANET_BOOTSTRAP 5638| | total_instruction_count += def->bytecode_length; 5639| | total_funcdefs_optimized++; 5640| |#endif 5641| 149k|} janet_verify: 5644| 141k|int janet_verify(JanetFuncDef *def) { 5645| 141k| int vargs = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG); ------------------ | | 1097| 141k|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ 5646| 141k| int32_t i; 5647| 141k| int32_t maxslot = def->arity + vargs; 5648| 141k| int32_t sc = def->slotcount; 5649| | 5650| 141k| if (def->environments_length > 256) return 15; ------------------ | Branch (5650:9): [True: 0, False: 141k] ------------------ 5651| 141k| if (def->bytecode_length == 0) return 1; ------------------ | Branch (5651:9): [True: 0, False: 141k] ------------------ 5652| | 5653| 141k| if (maxslot > sc) return 2; ------------------ | Branch (5653:9): [True: 0, False: 141k] ------------------ 5654| | 5655| | /* Verify each instruction */ 5656| 4.04M| for (i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (5656:17): [True: 3.90M, False: 141k] ------------------ 5657| 3.90M| uint32_t instr = def->bytecode[i]; 5658| | /* Check for invalid instructions */ 5659| 3.90M| if ((instr & 0x7F) >= JOP_INSTRUCTION_COUNT) { ------------------ | Branch (5659:13): [True: 0, False: 3.90M] ------------------ 5660| 0| return 3; 5661| 0| } 5662| 3.90M| enum JanetInstructionType type = janet_instructions[instr & 0x7F]; 5663| 3.90M| switch (type) { ------------------ | Branch (5663:17): [True: 3.90M, False: 0] ------------------ 5664| 20.3k| case JINT_0: ------------------ | Branch (5664:13): [True: 20.3k, False: 3.88M] ------------------ 5665| 20.3k| continue; 5666| 749k| case JINT_S: { ------------------ | Branch (5666:13): [True: 749k, False: 3.15M] ------------------ 5667| 749k| if ((int32_t)(instr >> 8) >= sc) return 4; ------------------ | Branch (5667:21): [True: 0, False: 749k] ------------------ 5668| 749k| continue; 5669| 749k| } 5670| 749k| case JINT_SI: ------------------ | Branch (5670:13): [True: 89.4k, False: 3.81M] ------------------ 5671| 89.4k| case JINT_SU: ------------------ | Branch (5671:13): [True: 0, False: 3.90M] ------------------ 5672| 89.4k| case JINT_ST: { ------------------ | Branch (5672:13): [True: 0, False: 3.90M] ------------------ 5673| 89.4k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5673:21): [True: 0, False: 89.4k] ------------------ 5674| 89.4k| continue; 5675| 89.4k| } 5676| 164k| case JINT_L: { ------------------ | Branch (5676:13): [True: 164k, False: 3.73M] ------------------ 5677| 164k| int32_t jumpdest = i + (((int32_t)instr) >> 8); 5678| 164k| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (5678:21): [True: 0, False: 164k] | Branch (5678:37): [True: 0, False: 164k] ------------------ 5679| 164k| continue; 5680| 164k| } 5681| 1.04M| case JINT_SS: { ------------------ | Branch (5681:13): [True: 1.04M, False: 2.85M] ------------------ 5682| 1.04M| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5682:21): [True: 0, False: 1.04M] ------------------ 5683| 1.04M| (int32_t)(instr >> 16) >= sc) return 4; ------------------ | Branch (5683:25): [True: 0, False: 1.04M] ------------------ 5684| 1.04M| continue; 5685| 1.04M| } 5686| 1.04M| case JINT_SSI: ------------------ | Branch (5686:13): [True: 68.9k, False: 3.83M] ------------------ 5687| 109k| case JINT_SSU: { ------------------ | Branch (5687:13): [True: 40.9k, False: 3.86M] ------------------ 5688| 109k| if ((int32_t)((instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5688:21): [True: 0, False: 109k] ------------------ 5689| 109k| (int32_t)((instr >> 16) & 0xFF) >= sc) return 4; ------------------ | Branch (5689:25): [True: 0, False: 109k] ------------------ 5690| 109k| continue; 5691| 109k| } 5692| 285k| case JINT_SL: { ------------------ | Branch (5692:13): [True: 285k, False: 3.61M] ------------------ 5693| 285k| int32_t jumpdest = i + (((int32_t)instr) >> 16); 5694| 285k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5694:21): [True: 0, False: 285k] ------------------ 5695| 285k| if (jumpdest < 0 || jumpdest >= def->bytecode_length) return 5; ------------------ | Branch (5695:21): [True: 0, False: 285k] | Branch (5695:37): [True: 0, False: 285k] ------------------ 5696| 285k| continue; 5697| 285k| } 5698| 525k| case JINT_SSS: { ------------------ | Branch (5698:13): [True: 525k, False: 3.37M] ------------------ 5699| 525k| if (((int32_t)(instr >> 8) & 0xFF) >= sc || ------------------ | Branch (5699:21): [True: 0, False: 525k] ------------------ 5700| 525k| ((int32_t)(instr >> 16) & 0xFF) >= sc || ------------------ | Branch (5700:25): [True: 0, False: 525k] ------------------ 5701| 525k| ((int32_t)(instr >> 24) & 0xFF) >= sc) return 4; ------------------ | Branch (5701:25): [True: 0, False: 525k] ------------------ 5702| 525k| continue; 5703| 525k| } 5704| 525k| case JINT_SD: { ------------------ | Branch (5704:13): [True: 41.1k, False: 3.86M] ------------------ 5705| 41.1k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5705:21): [True: 0, False: 41.1k] ------------------ 5706| 41.1k| if ((int32_t)(instr >> 16) >= def->defs_length) return 6; ------------------ | Branch (5706:21): [True: 0, False: 41.1k] ------------------ 5707| 41.1k| continue; 5708| 41.1k| } 5709| 712k| case JINT_SC: { ------------------ | Branch (5709:13): [True: 712k, False: 3.19M] ------------------ 5710| 712k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5710:21): [True: 0, False: 712k] ------------------ 5711| 712k| if ((int32_t)(instr >> 16) >= def->constants_length) return 7; ------------------ | Branch (5711:21): [True: 0, False: 712k] ------------------ 5712| 712k| continue; 5713| 712k| } 5714| 712k| case JINT_SES: { ------------------ | Branch (5714:13): [True: 161k, False: 3.74M] ------------------ 5715| | /* How can we check the last slot index? We need info parent funcdefs. Resort 5716| | * to runtime checks for now. Maybe invalid upvalue references could be defaulted 5717| | * to nil? (don't commit to this in the long term, though) */ 5718| 161k| if ((int32_t)((instr >> 8) & 0xFF) >= sc) return 4; ------------------ | Branch (5718:21): [True: 0, False: 161k] ------------------ 5719| 161k| if ((int32_t)((instr >> 16) & 0xFF) >= def->environments_length) return 8; ------------------ | Branch (5719:21): [True: 0, False: 161k] ------------------ 5720| 161k| continue; 5721| 161k| } 5722| 3.90M| } 5723| 3.90M| } 5724| | 5725| | /* Verify last instruction is either a jump, return, return-nil, or tailcall. Eventually, 5726| | * some real flow analysis would be ideal, but this should be very effective. Will completely 5727| | * prevent running over the end of bytecode. However, valid functions with dead code will 5728| | * be rejected. */ 5729| 141k| { 5730| 141k| uint32_t lastop = def->bytecode[def->bytecode_length - 1] & 0xFF; 5731| 141k| switch (lastop) { 5732| 0| default: ------------------ | Branch (5732:13): [True: 0, False: 141k] ------------------ 5733| 0| return 9; 5734| 83.1k| case JOP_RETURN: ------------------ | Branch (5734:13): [True: 83.1k, False: 58.0k] ------------------ 5735| 93.9k| case JOP_RETURN_NIL: ------------------ | Branch (5735:13): [True: 10.8k, False: 130k] ------------------ 5736| 94.2k| case JOP_JUMP: ------------------ | Branch (5736:13): [True: 264, False: 140k] ------------------ 5737| 96.0k| case JOP_ERROR: ------------------ | Branch (5737:13): [True: 1.84k, False: 139k] ------------------ 5738| 141k| case JOP_TAILCALL: ------------------ | Branch (5738:13): [True: 45.1k, False: 96.0k] ------------------ 5739| 141k| break; 5740| 141k| } 5741| 141k| } 5742| | 5743| | /* Verify debug info - slotmapping, etc. */ 5744| 1.48M| for (int32_t i = def->symbolmap_length - 1; i >= 0; i--) { ------------------ | Branch (5744:49): [True: 1.34M, False: 141k] ------------------ 5745| 1.34M| JanetSymbolMap jsm = def->symbolmap[i]; 5746| 1.34M| if (jsm.birth_pc == UINT32_MAX) { ------------------ | Branch (5746:13): [True: 692k, False: 650k] ------------------ 5747| 692k| if (jsm.death_pc >= (uint32_t) def->environments_length) { ------------------ | Branch (5747:17): [True: 0, False: 692k] ------------------ 5748| 0| return 10; 5749| | /* We should also check jsm.slot_index */ 5750| 0| } 5751| 692k| } else { 5752| 650k| if (jsm.slot_index >= (uint32_t) def->slotcount) { ------------------ | Branch (5752:17): [True: 0, False: 650k] ------------------ 5753| 0| return 11; 5754| 0| } 5755| 650k| if (jsm.birth_pc != UINT32_MAX && jsm.birth_pc >= (uint32_t) def->bytecode_length) { ------------------ | Branch (5755:17): [True: 650k, False: 0] | Branch (5755:47): [True: 0, False: 650k] ------------------ 5756| 0| return 12; 5757| 0| } 5758| 650k| if (jsm.death_pc != UINT32_MAX && jsm.death_pc > (uint32_t) def->bytecode_length) { ------------------ | Branch (5758:17): [True: 650k, False: 0] | Branch (5758:47): [True: 0, False: 650k] ------------------ 5759| 0| return 13; 5760| 0| } 5761| 650k| } 5762| 1.34M| if (jsm.symbol == NULL) { ------------------ | Branch (5762:13): [True: 0, False: 1.34M] ------------------ 5763| 0| return 14; 5764| 0| } 5765| 1.34M| } 5766| | 5767| 141k| return 0; 5768| 141k|} janet_funcdef_alloc: 5772| 149k|JanetFuncDef *janet_funcdef_alloc(void) { 5773| 149k| JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); 5774| 149k| def->environments = NULL; 5775| 149k| def->constants = NULL; 5776| 149k| def->bytecode = NULL; 5777| 149k| def->closure_bitset = NULL; 5778| 149k| def->flags = 0; 5779| 149k| def->slotcount = 0; 5780| 149k| def->symbolmap = NULL; 5781| 149k| def->arity = 0; 5782| 149k| def->min_arity = 0; 5783| 149k| def->max_arity = INT32_MAX; 5784| 149k| def->source = NULL; 5785| 149k| def->sourcemap = NULL; 5786| 149k| def->name = NULL; 5787| | def->defs = NULL; 5788| 149k| def->defs_length = 0; 5789| 149k| def->constants_length = 0; 5790| 149k| def->bytecode_length = 0; 5791| 149k| def->environments_length = 0; 5792| 149k| def->symbolmap_length = 0; 5793| 149k| def->named_args_count = 0; 5794| 149k| return def; 5795| 149k|} janet_signalv: 5878| 2.71k|void janet_signalv(JanetSignal sig, Janet message) { 5879| 2.71k| if (janet_vm.return_reg != NULL) { ------------------ | Branch (5879:9): [True: 2.71k, False: 0] ------------------ 5880| | /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */ 5881| 2.71k| if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) { ------------------ | Branch (5881:13): [True: 0, False: 2.71k] | Branch (5881:38): [True: 0, False: 0] ------------------ 5882| 0|#ifdef JANET_EV 5883| 0| if (NULL != janet_vm.root_fiber && sig == JANET_SIGNAL_EVENT) { ------------------ | Branch (5883:17): [True: 0, False: 0] | Branch (5883:48): [True: 0, False: 0] ------------------ 5884| 0| janet_vm.root_fiber->sched_id++; 5885| 0| } 5886| 0|#endif 5887| 0| if (sig != JANET_SIGNAL_ERROR) { ------------------ | Branch (5887:17): [True: 0, False: 0] ------------------ 5888| 0| message = janet_wrap_string(janet_formatc("%v coerced from %s to error", message, janet_signal_names[sig])); ------------------ | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5889| 0| } 5890| 0| sig = JANET_SIGNAL_ERROR; 5891| 0| } 5892| 2.71k| *janet_vm.return_reg = message; 5893| 2.71k| if (NULL != janet_vm.fiber) { ------------------ | Branch (5893:13): [True: 2.71k, False: 0] ------------------ 5894| 2.71k| janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP; ------------------ | | 837| 2.71k|#define JANET_FIBER_DID_LONGJUMP 0x8000000 ------------------ 5895| 2.71k| } 5896| |#if defined(JANET_BSD) || defined(JANET_APPLE) 5897| | _longjmp(*janet_vm.signal_buf, sig); 5898| |#else 5899| 2.71k| longjmp(*janet_vm.signal_buf, sig); 5900| 2.71k|#endif 5901| 2.71k| } else { 5902| 0| const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message); 5903| 0| janet_top_level_signal(str); 5904| 0| } 5905| 2.71k|} janet_panicv: 5907| 2.71k|void janet_panicv(Janet message) { 5908| 2.71k| janet_signalv(JANET_SIGNAL_ERROR, message); 5909| 2.71k|} janet_panicf: 5911| 2.71k|void janet_panicf(const char *format, ...) { 5912| 2.71k| va_list args; 5913| 2.71k| const uint8_t *ret; 5914| 2.71k| JanetBuffer buffer; 5915| 2.71k| int32_t len = 0; 5916| 67.8k| while (format[len]) len++; ------------------ | Branch (5916:12): [True: 65.1k, False: 2.71k] ------------------ 5917| 2.71k| janet_buffer_init(&buffer, len); 5918| 2.71k| va_start(args, format); 5919| 2.71k| janet_formatbv(&buffer, format, args); 5920| | va_end(args); 5921| 2.71k| ret = janet_string(buffer.data, buffer.count); 5922| 2.71k| janet_buffer_deinit(&buffer); 5923| 2.71k| janet_panics(ret); 5924| 2.71k|} janet_panics: 5930| 2.71k|void janet_panics(const uint8_t *message) { 5931| 2.71k| janet_panicv(janet_wrap_string(message)); ------------------ | | 848| 2.71k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 2.71k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.71k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.71k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5932| 2.71k|} janet_fixarity: 5942| 20.1M|void janet_fixarity(int32_t arity, int32_t fix) { 5943| 20.1M| if (arity != fix) ------------------ | Branch (5943:9): [True: 0, False: 20.1M] ------------------ 5944| 0| janet_panicf("arity mismatch, expected %d, got %d", fix, arity); 5945| 20.1M|} janet_arity: 5947| 7.21M|void janet_arity(int32_t arity, int32_t min, int32_t max) { 5948| 7.21M| if (min >= 0 && arity < min) ------------------ | Branch (5948:9): [True: 7.21M, False: 0] | Branch (5948:21): [True: 0, False: 7.21M] ------------------ 5949| 0| janet_panicf("arity mismatch, expected at least %d, got %d", min, arity); 5950| 7.21M| if (max >= 0 && arity > max) ------------------ | Branch (5950:9): [True: 2.96M, False: 4.24M] | Branch (5950:21): [True: 0, False: 2.96M] ------------------ 5951| 0| janet_panicf("arity mismatch, expected at most %d, got %d", max, arity); 5952| 7.21M|} janet_getmethod: 5978| 132|int janet_getmethod(const uint8_t *method, const JanetMethod *methods, Janet *out) { 5979| 3.30k| while (methods->name) { ------------------ | Branch (5979:12): [True: 3.16k, False: 132] ------------------ 5980| 3.16k| if (!janet_cstrcmp(method, methods->name)) { ------------------ | Branch (5980:13): [True: 0, False: 3.16k] ------------------ 5981| 0| *out = janet_wrap_cfunction(methods->cfun); ------------------ | | 853| 0|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5982| 0| return 1; 5983| 0| } 5984| 3.16k| methods++; 5985| 3.16k| } 5986| 132| return 0; 5987| 132|} janet_nextmethod: 5989| 3|Janet janet_nextmethod(const JanetMethod *methods, Janet key) { 5990| 3| if (!janet_checktype(key, JANET_NIL)) { ------------------ | | 806| 3| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 3] | | ------------------ | | 807| 3| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5990:9): [True: 0, False: 3] ------------------ 5991| 0| while (methods->name) { ------------------ | Branch (5991:16): [True: 0, False: 0] ------------------ 5992| 0| if (janet_keyeq(key, methods->name)) { ------------------ | Branch (5992:17): [True: 0, False: 0] ------------------ 5993| 0| methods++; 5994| 0| break; 5995| 0| } 5996| 0| methods++; 5997| 0| } 5998| 0| } 5999| 3| if (methods->name) { ------------------ | Branch (5999:9): [True: 3, False: 0] ------------------ 6000| 3| return janet_ckeywordv(methods->name); ------------------ | | 1843| 3|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 3|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 3| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 3|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 3|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6001| 3| } else { 6002| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6003| 0| } 6004| 3|} janet_getcbytes: 6055| 2|const char *janet_getcbytes(const Janet *argv, int32_t n) { 6056| | /* Ensure buffer 0-padded */ 6057| 2| if (janet_checktype(argv[n], JANET_BUFFER)) { ------------------ | | 806| 2| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 2] | | | Branch (806:6): [Folded, False: 2] | | ------------------ | | 807| 2| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6058| 0| JanetBuffer *b = janet_unwrap_buffer(argv[n]); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 6059| 0| if ((b->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) && b->count == b->capacity) { ------------------ | | 1780| 0|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (6059:13): [True: 0, False: 0] | Branch (6059:61): [True: 0, False: 0] ------------------ 6060| | /* Make a copy with janet_smalloc in the rare case we have a buffer that 6061| | * cannot be realloced and pushing a 0 byte would panic. */ 6062| 0| char *new_string = janet_smalloc(b->count + 1); 6063| 0| memcpy(new_string, b->data, b->count); 6064| 0| new_string[b->count] = 0; 6065| 0| if (strlen(new_string) != (size_t) b->count) goto badzeros; ------------------ | Branch (6065:17): [True: 0, False: 0] ------------------ 6066| 0| return new_string; 6067| 0| } else { 6068| | /* Ensure trailing 0 */ 6069| 0| janet_buffer_push_u8(b, 0); 6070| 0| b->count--; 6071| 0| if (strlen((char *)b->data) != (size_t) b->count) goto badzeros; ------------------ | Branch (6071:17): [True: 0, False: 0] ------------------ 6072| 0| return (const char *) b->data; 6073| 0| } 6074| 0| } 6075| 2| JanetByteView view = janet_getbytes(argv, n); 6076| 2| const char *cstr = (const char *)view.bytes; 6077| 2| if (strlen(cstr) != (size_t) view.len) goto badzeros; ------------------ | Branch (6077:9): [True: 0, False: 2] ------------------ 6078| 2| return cstr; 6079| | 6080| 0|badzeros: 6081| 0| janet_panic("bytes contain embedded 0s"); 6082| 2|} janet_getnat: 6091| 2|int32_t janet_getnat(const Janet *argv, int32_t n) { 6092| 2| Janet x = argv[n]; 6093| 2| if (!janet_checkint(x)) goto bad; ------------------ | Branch (6093:9): [True: 0, False: 2] ------------------ 6094| 2| int32_t ret = janet_unwrap_integer(x); ------------------ | | 966| 2|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 2|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 6095| 2| if (ret < 0) goto bad; ------------------ | Branch (6095:9): [True: 0, False: 2] ------------------ 6096| 2| return ret; 6097| 0|bad: 6098| 0| janet_panicf("bad slot #%d, expected non-negative 32 bit signed integer, got %v", n, x); 6099| 2|} janet_symeq: 6121| 186k|int janet_symeq(Janet x, const char *cstring) { 6122| 186k| return janet_strlike_cmp(JANET_SYMBOL, x, cstring); 6123| 186k|} janet_getinteger: 6125| 2.67M|int32_t janet_getinteger(const Janet *argv, int32_t n) { 6126| 2.67M| Janet x = argv[n]; 6127| 2.67M| if (!janet_checkint(x)) { ------------------ | Branch (6127:9): [True: 0, False: 2.67M] ------------------ 6128| 0| janet_panicf("bad slot #%d, expected 32 bit signed integer, got %v", n, x); 6129| 0| } 6130| 2.67M| return janet_unwrap_integer(x); ------------------ | | 966| 2.67M|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 2.67M|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 6131| 2.67M|} janet_gethalfrange: 6205| 717k|int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) { 6206| 717k| int32_t raw = janet_getinteger(argv, n); 6207| 717k| int32_t not_raw = raw; 6208| 717k| if (not_raw < 0) not_raw += length + 1; ------------------ | Branch (6208:9): [True: 35.1k, False: 682k] ------------------ 6209| 717k| if (not_raw < 0 || not_raw > length) ------------------ | Branch (6209:9): [True: 0, False: 717k] | Branch (6209:24): [True: 0, False: 717k] ------------------ 6210| 0| janet_panicf("%s index %d out of range [%d,%d]", which, (int64_t) raw, -(int64_t)length - 1, (int64_t) length); 6211| 717k| return not_raw; 6212| 717k|} janet_getstartrange: 6214| 2.20M|int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) { 6215| 2.20M| if (n >= argc || janet_checktype(argv[n], JANET_NIL)) { ------------------ | | 806| 669k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 669k] | | | Branch (806:6): [Folded, False: 669k] | | ------------------ | | 807| 669k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 669k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 669k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 669k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 669k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 669k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6215:9): [True: 1.53M, False: 669k] ------------------ 6216| 1.53M| return 0; 6217| 1.53M| } 6218| 669k| return janet_gethalfrange(argv, n, length, "start"); 6219| 2.20M|} janet_getendrange: 6221| 2.20M|int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) { 6222| 2.20M| if (n >= argc || janet_checktype(argv[n], JANET_NIL)) { ------------------ | | 806| 47.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 47.9k] | | | Branch (806:6): [Folded, False: 47.9k] | | ------------------ | | 807| 47.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 47.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 47.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 47.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 47.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 47.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6222:9): [True: 2.15M, False: 47.9k] ------------------ 6223| 2.15M| return length; 6224| 2.15M| } 6225| 47.9k| return janet_gethalfrange(argv, n, length, "end"); 6226| 2.20M|} janet_getindexed: 6237| 2.20M|JanetView janet_getindexed(const Janet *argv, int32_t n) { 6238| 2.20M| Janet x = argv[n]; 6239| 2.20M| JanetView view; 6240| 2.20M| if (!janet_indexed_view(x, &view.items, &view.len)) { ------------------ | Branch (6240:9): [True: 0, False: 2.20M] ------------------ 6241| 0| janet_panic_type(x, n, JANET_TFLAG_INDEXED); ------------------ | | 613| 0|#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | ------------------ | | | | 602| 0|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) | | ------------------ | | #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | ------------------ | | | | 603| 0|#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) | | ------------------ ------------------ 6242| 0| } 6243| 2.20M| return view; 6244| 2.20M|} janet_getbytes: 6246| 723k|JanetByteView janet_getbytes(const Janet *argv, int32_t n) { 6247| 723k| Janet x = argv[n]; 6248| 723k| JanetByteView view; 6249| 723k| if (!janet_bytes_view(x, &view.bytes, &view.len)) { ------------------ | Branch (6249:9): [True: 0, False: 723k] ------------------ 6250| 0| janet_panic_type(x, n, JANET_TFLAG_BYTES); ------------------ | | 612| 0|#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 599| 0|#define JANET_TFLAG_STRING (1 << JANET_STRING) | | ------------------ | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 600| 0|#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) | | ------------------ | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 606| 0|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) | | ------------------ | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | ------------------ | | | | 601| 0|#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) | | ------------------ ------------------ 6251| 0| } 6252| 723k| return view; 6253| 723k|} janet_getslice: 6276| 2.20M|JanetRange janet_getslice(int32_t argc, const Janet *argv) { 6277| 2.20M| janet_arity(argc, 1, 3); 6278| 2.20M| JanetRange range; 6279| 2.20M| int32_t length = janet_length(argv[0]); 6280| 2.20M| range.start = janet_getstartrange(argv, argc, 1, length); 6281| 2.20M| range.end = janet_getendrange(argv, argc, 2, length); 6282| 2.20M| if (range.end < range.start) ------------------ | Branch (6282:9): [True: 0, False: 2.20M] ------------------ 6283| 0| range.end = range.start; 6284| 2.20M| return range; 6285| 2.20M|} janet_optnat: 6360| 8.29k|int32_t janet_optnat(const Janet *argv, int32_t argc, int32_t n, int32_t dflt) { 6361| 8.29k| if (argc <= n) return dflt; ------------------ | Branch (6361:9): [True: 8.29k, False: 0] ------------------ 6362| 0| if (janet_checktype(argv[n], JANET_NIL)) return dflt; ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6363| 0| return janet_getnat(argv, n); 6364| 0|} janet_optinteger: 6366| 435|int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, int32_t dflt) { 6367| 435| if (argc <= n) return dflt; ------------------ | Branch (6367:9): [True: 435, False: 0] ------------------ 6368| 0| if (janet_checktype(argv[n], JANET_NIL)) return dflt; ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6369| 0| return janet_getinteger(argv, n); 6370| 0|} janet_atomic_load_relaxed: 6440| 54.1M|JanetAtomicInt janet_atomic_load_relaxed(JanetAtomicInt volatile *x) { 6441| |#ifdef _MSC_VER 6442| | return _InterlockedOr(x, 0); 6443| |#elif defined(JANET_PLAN9) 6444| | return agetl((void *)x); 6445| |#elif defined(JANET_USE_STDATOMIC) 6446| | return atomic_load_explicit(x, memory_order_relaxed); 6447| |#else 6448| 54.1M| return __atomic_load_n(x, __ATOMIC_RELAXED); 6449| 54.1M|#endif 6450| 54.1M|} janetc_funopt: 6883| 190k|const JanetFunOptimizer *janetc_funopt(uint32_t flags) { 6884| 190k| uint32_t tag = flags & JANET_FUNCDEF_FLAG_TAG; ------------------ | | 1108| 190k|#define JANET_FUNCDEF_FLAG_TAG 0xFFFF ------------------ 6885| 190k| if (tag == 0) ------------------ | Branch (6885:9): [True: 0, False: 190k] ------------------ 6886| 0| return NULL; 6887| 190k| uint32_t index = tag - 1; 6888| 190k| if (index >= (sizeof(optimizers) / sizeof(optimizers[0]))) ------------------ | Branch (6888:9): [True: 0, False: 190k] ------------------ 6889| 0| return NULL; 6890| 190k| return optimizers + index; 6891| 190k|} janetc_fopts_default: 6931| 1.13M|JanetFopts janetc_fopts_default(JanetCompiler *c) { 6932| 1.13M| JanetFopts ret; 6933| 1.13M| ret.compiler = c; 6934| 1.13M| ret.flags = 0; 6935| 1.13M| ret.hint = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 1.13M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.13M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.13M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.13M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6936| 1.13M| return ret; 6937| 1.13M|} janetc_error: 6940| 1.23M|void janetc_error(JanetCompiler *c, const uint8_t *m) { 6941| | /* Don't override first error */ 6942| 1.23M| if (c->result.status == JANET_COMPILE_ERROR) { ------------------ | Branch (6942:9): [True: 1.19M, False: 39.3k] ------------------ 6943| 1.19M| return; 6944| 1.19M| } 6945| 39.3k| c->result.status = JANET_COMPILE_ERROR; 6946| 39.3k| c->result.error = m; 6947| 39.3k|} janetc_cerror: 6950| 1.14M|void janetc_cerror(JanetCompiler *c, const char *m) { 6951| 1.14M| janetc_error(c, janet_cstring(m)); 6952| 1.14M|} janetc_lintf: 6961| 1.94M|void janetc_lintf(JanetCompiler *c, JanetCompileLintLevel level, const char *format, ...) { 6962| 1.94M| if (NULL != c->lints) { ------------------ | Branch (6962:9): [True: 0, False: 1.94M] ------------------ 6963| | /* format message */ 6964| 0| va_list args; 6965| 0| JanetBuffer buffer; 6966| 0| int32_t len = 0; 6967| 0| while (format[len]) len++; ------------------ | Branch (6967:16): [True: 0, False: 0] ------------------ 6968| 0| janet_buffer_init(&buffer, len); 6969| 0| va_start(args, format); 6970| 0| janet_formatbv(&buffer, format, args); 6971| 0| va_end(args); 6972| 0| const uint8_t *str = janet_string(buffer.data, buffer.count); 6973| 0| janet_buffer_deinit(&buffer); 6974| | /* construct linting payload */ 6975| 0| Janet *payload = janet_tuple_begin(4); 6976| 0| payload[0] = janet_ckeywordv(janet_lint_level_names[level]); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6977| 0| payload[1] = c->current_mapping.line == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.line); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ payload[1] = c->current_mapping.line == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.line); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ | Branch (6977:22): [True: 0, False: 0] ------------------ 6978| 0| payload[2] = c->current_mapping.column == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.column); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ payload[2] = c->current_mapping.column == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.column); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ | Branch (6978:22): [True: 0, False: 0] ------------------ 6979| 0| payload[3] = janet_wrap_string(str); ------------------ | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6980| 0| janet_array_push(c->lints, janet_wrap_tuple(janet_tuple_end(payload))); ------------------ | | 843| 0|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6981| 0| } 6982| 1.94M|} janetc_freeslot: 6985| 7.51M|void janetc_freeslot(JanetCompiler *c, JanetSlot s) { 6986| 7.51M| if (s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF | JANET_SLOT_NAMED)) return; ------------------ | | 1038| 7.51M|#define JANET_SLOT_CONSTANT 0x10000 ------------------ if (s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF | JANET_SLOT_NAMED)) return; ------------------ | | 1041| 7.51M|#define JANET_SLOT_REF 0x80000 ------------------ if (s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF | JANET_SLOT_NAMED)) return; ------------------ | | 1039| 7.51M|#define JANET_SLOT_NAMED 0x20000 ------------------ | Branch (6986:9): [True: 3.77M, False: 3.73M] ------------------ 6987| 3.73M| if (s.envindex >= 0) return; ------------------ | Branch (6987:9): [True: 0, False: 3.73M] ------------------ 6988| 3.73M| janetc_regalloc_free(&c->scope->ra, s.index); 6989| 3.73M|} janetc_nameslot: 6992| 1.28M|void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s, uint32_t flags) { 6993| 1.28M| if (!(flags & JANET_DEFFLAG_NO_SHADOWCHECK)) { ------------------ | | 1182| 1.28M|#define JANET_DEFFLAG_NO_SHADOWCHECK 1 ------------------ | Branch (6993:9): [True: 1.28M, False: 792] ------------------ 6994| 1.28M| if (sym[0] != '_') { ------------------ | Branch (6994:13): [True: 1.18M, False: 98.0k] ------------------ 6995| 1.18M| switch (janetc_shadowcheck(c, sym)) { 6996| 5.51k| default: ------------------ | Branch (6996:17): [True: 5.51k, False: 1.18M] ------------------ 6997| 5.51k| break; 6998| 5.51k| case JANETC_SHADOW_MACRO: ------------------ | Branch (6998:17): [True: 2.78k, False: 1.18M] ------------------ 6999| 2.78k| janetc_lintf(c, JANET_C_LINT_NORMAL, "binding %q is shadowing a macro", janet_wrap_symbol(sym)); ------------------ | | 849| 2.78k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 2.78k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.78k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.78k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7000| 2.78k| break; 7001| 1.17M| case JANETC_SHADOW_LOCAL_HIDES_LOCAL: ------------------ | Branch (7001:17): [True: 1.17M, False: 11.4k] ------------------ 7002| 1.17M| janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is shadowing a binding", janet_wrap_symbol(sym)); ------------------ | | 849| 1.17M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 1.17M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.17M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.17M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7003| 1.17M| break; 7004| 3.04k| case JANETC_SHADOW_LOCAL_HIDES_GLOBAL: ------------------ | Branch (7004:17): [True: 3.04k, False: 1.18M] ------------------ 7005| 3.04k| janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is shadowing a top-level binding", janet_wrap_symbol(sym)); ------------------ | | 849| 3.04k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 3.04k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3.04k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.04k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7006| 3.04k| break; 7007| 144| case JANETC_SHADOW_GLOBAL_HIDES_GLOBAL: ------------------ | Branch (7007:17): [True: 144, False: 1.18M] ------------------ 7008| 144| janetc_lintf(c, JANET_C_LINT_STRICT, "top-level binding %q is shadowing another top-level binding", janet_wrap_symbol(sym)); ------------------ | | 849| 144|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 144| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 144|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 144|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7009| 144| break; 7010| 1.18M| } 7011| 1.18M| } 7012| 1.28M| } 7013| 1.28M| SymPair sp; 7014| 1.28M| int32_t cnt = janet_v_count(c->buffer); ------------------ | | 759| 1.28M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.28M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.28M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.28M, False: 390] | | ------------------ ------------------ 7015| 1.28M| sp.sym = sym; 7016| 1.28M| sp.sym2 = sym; 7017| 1.28M| sp.slot = s; 7018| 1.28M| sp.keep = 0; 7019| 1.28M| if (flags & JANET_DEFFLAG_NO_UNUSED) { ------------------ | | 1183| 1.28M|#define JANET_DEFFLAG_NO_UNUSED 2 ------------------ | Branch (7019:9): [True: 954, False: 1.28M] ------------------ 7020| 954| sp.referenced = 1; 7021| 1.28M| } else { 7022| 1.28M| sp.referenced = sym[0] == '_'; /* Fake ref if symbol starts with _ to avoid lints */ 7023| 1.28M| } 7024| 1.28M| sp.slot.flags |= JANET_SLOT_NAMED; ------------------ | | 1039| 1.28M|#define JANET_SLOT_NAMED 0x20000 ------------------ 7025| 1.28M| sp.birth_pc = cnt ? cnt - 1 : 0; ------------------ | Branch (7025:19): [True: 1.28M, False: 390] ------------------ 7026| 1.28M| sp.death_pc = UINT32_MAX; 7027| | janet_v_push(c->scope->syms, sp); ------------------ | | 757| 1.28M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.28M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.28M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.27M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.27M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.27M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.27M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 6.34k, False: 1.27M] | | | | | | | Branch (768:50): [True: 14.3k, False: 1.26M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 20.7k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.28M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.28M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7028| 1.28M|} janetc_cslot: 7031| 5.85M|JanetSlot janetc_cslot(Janet x) { 7032| 5.85M| JanetSlot ret; 7033| 5.85M| ret.flags = (1 << janet_type(x)) | JANET_SLOT_CONSTANT; ------------------ | | 795| 5.85M| (isnan((x).number) \ | | 796| 5.85M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 5.85M| : JANET_NUMBER) ------------------ ret.flags = (1 << janet_type(x)) | JANET_SLOT_CONSTANT; ------------------ | | 1038| 5.85M|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (7033:23): [True: 5.30M, False: 551k] ------------------ 7034| 5.85M| ret.index = -1; 7035| 5.85M| ret.constant = x; 7036| 5.85M| ret.envindex = -1; 7037| 5.85M| return ret; 7038| 5.85M|} janetc_farslot: 7041| 3.27M|JanetSlot janetc_farslot(JanetCompiler *c) { 7042| 3.27M| JanetSlot ret; 7043| 3.27M| ret.flags = JANET_SLOTTYPE_ANY; ------------------ | | 1048| 3.27M|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ 7044| 3.27M| ret.index = janetc_allocfar(c); 7045| 3.27M| ret.constant = janet_wrap_nil(); ------------------ | | 831| 3.27M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 3.27M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3.27M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.27M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7046| 3.27M| ret.envindex = -1; 7047| 3.27M| return ret; 7048| 3.27M|} janetc_scope: 7051| 224k|void janetc_scope(JanetScope *s, JanetCompiler *c, int flags, const char *name) { 7052| 224k| JanetScope scope; 7053| 224k| scope.name = name; 7054| 224k| scope.child = NULL; 7055| 224k| scope.consts = NULL; 7056| 224k| scope.syms = NULL; 7057| 224k| scope.envs = NULL; 7058| 224k| scope.defs = NULL; 7059| 224k| scope.bytecode_start = janet_v_count(c->buffer); ------------------ | | 759| 224k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 114k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 114k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 114k, False: 110k] | | ------------------ ------------------ 7060| 224k| scope.flags = flags; 7061| 224k| scope.parent = c->scope; 7062| 224k| janetc_regalloc_init(&scope.ua); 7063| | /* Inherit slots */ 7064| 224k| if ((!(flags & JANET_SCOPE_FUNCTION)) && c->scope) { ------------------ | | 1058| 224k|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (7064:9): [True: 20.5k, False: 204k] | Branch (7064:46): [True: 20.5k, False: 0] ------------------ 7065| 20.5k| janetc_regalloc_clone(&scope.ra, &(c->scope->ra)); 7066| 204k| } else { 7067| 204k| janetc_regalloc_init(&scope.ra); 7068| 204k| } 7069| | /* Link parent and child and update pointer */ 7070| 224k| if (c->scope) ------------------ | Branch (7070:9): [True: 167k, False: 57.2k] ------------------ 7071| 167k| c->scope->child = s; 7072| 224k| c->scope = s; 7073| 224k| *s = scope; 7074| 224k|} janetc_popscope: 7077| 224k|void janetc_popscope(JanetCompiler *c) { 7078| 224k| JanetScope *oldscope = c->scope; 7079| 224k| JanetScope *newscope = oldscope->parent; 7080| | /* Move free slots to parent scope if not a new function. 7081| | * We need to know the total number of slots used when compiling the function. */ 7082| 224k| if (!(oldscope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_UNUSED)) && newscope) { ------------------ | | 1058| 224k|#define JANET_SCOPE_FUNCTION 1 ------------------ if (!(oldscope->flags & (JANET_SCOPE_FUNCTION | JANET_SCOPE_UNUSED)) && newscope) { ------------------ | | 1061| 224k|#define JANET_SCOPE_UNUSED 8 ------------------ | Branch (7082:9): [True: 19.6k, False: 205k] | Branch (7082:77): [True: 19.6k, False: 0] ------------------ 7083| | /* Parent scopes inherit child's closure flag. Needed 7084| | * for while loops. (if a while loop creates a closure, it 7085| | * is compiled to a tail recursive iife) */ 7086| 19.6k| if (oldscope->flags & JANET_SCOPE_CLOSURE) { ------------------ | | 1062| 19.6k|#define JANET_SCOPE_CLOSURE 16 ------------------ | Branch (7086:13): [True: 10.7k, False: 8.85k] ------------------ 7087| 10.7k| newscope->flags |= JANET_SCOPE_CLOSURE; ------------------ | | 1062| 10.7k|#define JANET_SCOPE_CLOSURE 16 ------------------ 7088| 10.7k| } 7089| 19.6k| if (newscope->ra.max < oldscope->ra.max) { ------------------ | Branch (7089:13): [True: 11.7k, False: 7.85k] ------------------ 7090| 11.7k| newscope->ra.max = oldscope->ra.max; 7091| 11.7k| } 7092| | 7093| | /* Keep upvalue slots and symbols for debugging. */ 7094| 1.28M| for (int32_t i = 0; i < janet_v_count(oldscope->syms); i++) { ------------------ | | 759| 1.28M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.27M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.27M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.27M, False: 12.9k] | | ------------------ ------------------ | Branch (7094:29): [True: 1.26M, False: 19.6k] ------------------ 7095| 1.26M| SymPair pair = oldscope->syms[i]; 7096| | /* Check for unused symbols */ 7097| 1.26M| if (pair.referenced == 0 && pair.sym) { ------------------ | Branch (7097:17): [True: 1.11M, False: 144k] | Branch (7097:41): [True: 470k, False: 647k] ------------------ 7098| 470k| janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is unused", janet_wrap_symbol(pair.sym)); ------------------ | | 849| 470k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 470k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 470k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 470k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7099| 470k| } 7100| | /* The variable should not be lexically accessible */ 7101| 1.26M| pair.sym = NULL; 7102| 1.26M| if (pair.death_pc == UINT32_MAX) { ------------------ | Branch (7102:17): [True: 568k, False: 695k] ------------------ 7103| 568k| pair.death_pc = (uint32_t) janet_v_count(c->buffer); ------------------ | | 759| 568k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 568k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 568k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 568k, False: 0] | | ------------------ ------------------ 7104| 568k| } 7105| 1.26M| if (pair.keep) { ------------------ | Branch (7105:17): [True: 19.6k, False: 1.24M] ------------------ 7106| | /* The variable should also not be included in the locals */ 7107| 19.6k| pair.sym2 = NULL; 7108| 19.6k| janetc_regalloc_touch(&newscope->ra, pair.slot.index); 7109| 19.6k| } 7110| 1.26M| janet_v_push(newscope->syms, pair); ------------------ | | 757| 1.26M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.26M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.26M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.25M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.25M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.25M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.25M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.73k, False: 1.25M] | | | | | | | Branch (768:50): [True: 18.7k, False: 1.23M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 24.4k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.26M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.26M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7111| 1.26M| } 7112| 19.6k| } 7113| | 7114| | /* Free the old scope */ 7115| 224k| janet_v_free(oldscope->consts); ------------------ | | 756| 224k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 57.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 57.5k, False: 167k] | | ------------------ ------------------ 7116| 224k| janet_v_free(oldscope->syms); ------------------ | | 756| 224k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 12.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 12.0k, False: 212k] | | ------------------ ------------------ 7117| 224k| janet_v_free(oldscope->envs); ------------------ | | 756| 224k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 5.46k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 5.46k, False: 219k] | | ------------------ ------------------ 7118| 224k| janet_v_free(oldscope->defs); ------------------ | | 756| 224k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 80.8k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 80.8k, False: 143k] | | ------------------ ------------------ 7119| 224k| janetc_regalloc_deinit(&oldscope->ra); 7120| 224k| janetc_regalloc_deinit(&oldscope->ua); 7121| | /* Update pointer */ 7122| 224k| if (newscope) ------------------ | Branch (7122:9): [True: 167k, False: 57.2k] ------------------ 7123| 167k| newscope->child = NULL; 7124| 224k| c->scope = newscope; 7125| 224k|} janetc_popscope_keepslot: 7128| 8.68k|void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot) { 7129| 8.68k| JanetScope *scope; 7130| 8.68k| janetc_popscope(c); 7131| 8.68k| scope = c->scope; 7132| 8.68k| if (scope && retslot.envindex < 0 && retslot.index >= 0) { ------------------ | Branch (7132:9): [True: 8.68k, False: 0] | Branch (7132:18): [True: 8.68k, False: 2] | Branch (7132:42): [True: 2.89k, False: 5.79k] ------------------ 7133| 2.89k| janetc_regalloc_touch(&scope->ra, retslot.index); 7134| 2.89k| } 7135| 8.68k|} janetc_shadowcheck: 7172| 1.18M|Shadowing janetc_shadowcheck(JanetCompiler *c, const uint8_t *sym) { 7173| | /* Check locals */ 7174| 1.18M| JanetScope *scope = c->scope; 7175| 1.18M| int is_global = (scope->flags & JANET_SCOPE_TOP); ------------------ | | 1060| 1.18M|#define JANET_SCOPE_TOP 4 ------------------ 7176| 1.27M| while (scope) { ------------------ | Branch (7176:12): [True: 1.26M, False: 11.3k] ------------------ 7177| 1.26M| int32_t len = janet_v_count(scope->syms); ------------------ | | 759| 1.26M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.21M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.21M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.21M, False: 52.7k] | | ------------------ ------------------ 7178| 20.0M| for (int32_t i = len - 1; i >= 0; i--) { ------------------ | Branch (7178:35): [True: 19.9M, False: 90.8k] ------------------ 7179| 19.9M| SymPair *pair = scope->syms + i; 7180| 19.9M| if (pair->sym == sym) { ------------------ | Branch (7180:17): [True: 1.17M, False: 18.7M] ------------------ 7181| 1.17M| if (is_global) { ------------------ | Branch (7181:21): [True: 144, False: 1.17M] ------------------ 7182| | /* This can happen in a top level form like (def [x [x y]] [1 [2 3]])` where a symbol is reused in one expression */ 7183| | /* janet_assert(!is_global, "shadowing analysis is incorrect. compiler bug"); */ 7184| 144| return JANETC_SHADOW_GLOBAL_HIDES_GLOBAL; 7185| 144| } 7186| 1.17M| return JANETC_SHADOW_LOCAL_HIDES_LOCAL; 7187| 1.17M| } 7188| 19.9M| } 7189| 90.8k| scope = scope->parent; 7190| 90.8k| } 7191| | /* Check globals */ 7192| 11.3k| JanetBinding binding = janet_resolve_ext(c->env, sym); 7193| 11.3k| if (binding.type == JANET_BINDING_MACRO || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (7193:9): [True: 2.78k, False: 8.55k] | Branch (7193:48): [True: 0, False: 8.55k] ------------------ 7194| 2.78k| return JANETC_SHADOW_MACRO; 7195| 8.55k| } else if (binding.type == JANET_BINDING_NONE) { ------------------ | Branch (7195:16): [True: 5.51k, False: 3.04k] ------------------ 7196| 5.51k| return JANETC_SHADOW_NONE; 7197| 5.51k| } else { 7198| 3.04k| if (is_global) { ------------------ | Branch (7198:13): [True: 0, False: 3.04k] ------------------ 7199| 0| return JANETC_SHADOW_GLOBAL_HIDES_GLOBAL; 7200| 3.04k| } else { 7201| 3.04k| return JANETC_SHADOW_LOCAL_HIDES_GLOBAL; 7202| 3.04k| } 7203| 3.04k| } 7204| 11.3k|} janetc_resolve: 7209| 524k| const uint8_t *sym) { 7210| | 7211| 524k| JanetSlot ret = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 524k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 524k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 524k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 524k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7212| 524k| JanetScope *scope = c->scope; 7213| 524k| SymPair *pair; 7214| 524k| int foundlocal = 1; 7215| 524k| int unused = 0; 7216| | 7217| | /* Search scopes for symbol, starting from top */ 7218| 1.10M| while (scope) { ------------------ | Branch (7218:12): [True: 782k, False: 320k] ------------------ 7219| 782k| int32_t i, len; 7220| 782k| if (scope->flags & JANET_SCOPE_UNUSED) ------------------ | | 1061| 782k|#define JANET_SCOPE_UNUSED 8 ------------------ | Branch (7220:13): [True: 81, False: 782k] ------------------ 7221| 81| unused = 1; 7222| 782k| len = janet_v_count(scope->syms); ------------------ | | 759| 782k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 213k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 213k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 213k, False: 569k] | | ------------------ ------------------ 7223| | /* Search in reverse order */ 7224| 2.53M| for (i = len - 1; i >= 0; i--) { ------------------ | Branch (7224:27): [True: 1.95M, False: 577k] ------------------ 7225| 1.95M| pair = scope->syms + i; 7226| 1.95M| if (pair->sym == sym) { ------------------ | Branch (7226:17): [True: 204k, False: 1.75M] ------------------ 7227| 204k| ret = pair->slot; 7228| 204k| pair->referenced = 1; 7229| 204k| goto found; 7230| 204k| } 7231| 1.95M| } 7232| 577k| if (scope->flags & JANET_SCOPE_FUNCTION) ------------------ | | 1058| 577k|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (7232:13): [True: 554k, False: 23.5k] ------------------ 7233| 554k| foundlocal = 0; 7234| 577k| scope = scope->parent; 7235| 577k| } 7236| | 7237| | /* Symbol not found - check for global */ 7238| 320k| { 7239| 320k| JanetBinding binding = janet_resolve_ext(c->env, sym); 7240| 320k| if (binding.type == JANET_BINDING_NONE) { ------------------ | Branch (7240:13): [True: 10.0k, False: 310k] ------------------ 7241| 10.0k| Janet handler = janet_table_get_keyword(c->env, "missing-symbol"); 7242| 10.0k| switch (janet_type(handler)) { ------------------ | | 795| 10.0k| (isnan((x).number) \ | | 796| 10.0k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 10.0k| : JANET_NUMBER) ------------------ | Branch (7242:21): [True: 10.0k, False: 0] ------------------ 7243| 10.0k| case JANET_NIL: ------------------ | Branch (7243:17): [True: 10.0k, False: 0] ------------------ 7244| 10.0k| break; 7245| 0| case JANET_FUNCTION: ------------------ | Branch (7245:17): [True: 0, False: 10.0k] ------------------ 7246| 0| if (!lookup_missing(c, sym, janet_unwrap_function(handler), &binding)) ------------------ | | 868| 0|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ | Branch (7246:25): [True: 0, False: 0] ------------------ 7247| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7248| 0| break; 7249| 0| default: ------------------ | Branch (7249:17): [True: 0, False: 10.0k] ------------------ 7250| 0| janetc_error(c, janet_formatc("invalid lookup handler %V", handler)); 7251| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7252| 10.0k| } 7253| 10.0k| } 7254| | 7255| 320k| switch (binding.type) { 7256| 0| default: ------------------ | Branch (7256:13): [True: 0, False: 320k] ------------------ 7257| 10.0k| case JANET_BINDING_NONE: ------------------ | Branch (7257:13): [True: 10.0k, False: 310k] ------------------ 7258| 10.0k| janetc_error(c, janet_formatc("unknown symbol %q", janet_wrap_symbol(sym))); ------------------ | | 849| 10.0k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 10.0k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 10.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 10.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7259| 10.0k| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 10.0k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 10.0k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 10.0k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 10.0k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7260| 275k| case JANET_BINDING_DEF: ------------------ | Branch (7260:13): [True: 275k, False: 44.6k] ------------------ 7261| 276k| case JANET_BINDING_MACRO: /* Macro should function like defs when not in calling pos */ ------------------ | Branch (7261:13): [True: 1.08k, False: 319k] ------------------ 7262| 276k| ret = janetc_cslot(binding.value); 7263| 276k| break; 7264| 0| case JANET_BINDING_DYNAMIC_DEF: ------------------ | Branch (7264:13): [True: 0, False: 320k] ------------------ 7265| 0| case JANET_BINDING_DYNAMIC_MACRO: ------------------ | Branch (7265:13): [True: 0, False: 320k] ------------------ 7266| 0| ret = janetc_cslot(binding.value); 7267| 0| ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOTTYPE_ANY; ------------------ | | 1041| 0|#define JANET_SLOT_REF 0x80000 ------------------ ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOTTYPE_ANY; ------------------ | | 1039| 0|#define JANET_SLOT_NAMED 0x20000 ------------------ ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOTTYPE_ANY; ------------------ | | 1048| 0|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ 7268| 0| ret.flags &= ~JANET_SLOT_CONSTANT; ------------------ | | 1038| 0|#define JANET_SLOT_CONSTANT 0x10000 ------------------ 7269| 0| break; 7270| 33.5k| case JANET_BINDING_VAR: { ------------------ | Branch (7270:13): [True: 33.5k, False: 286k] ------------------ 7271| 33.5k| ret = janetc_cslot(binding.value); 7272| 33.5k| ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY; ------------------ | | 1041| 33.5k|#define JANET_SLOT_REF 0x80000 ------------------ ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY; ------------------ | | 1039| 33.5k|#define JANET_SLOT_NAMED 0x20000 ------------------ ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY; ------------------ | | 1040| 33.5k|#define JANET_SLOT_MUTABLE 0x40000 ------------------ ret.flags |= JANET_SLOT_REF | JANET_SLOT_NAMED | JANET_SLOT_MUTABLE | JANET_SLOTTYPE_ANY; ------------------ | | 1048| 33.5k|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ 7273| 33.5k| ret.flags &= ~JANET_SLOT_CONSTANT; ------------------ | | 1038| 33.5k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ 7274| 33.5k| break; 7275| 0| } 7276| 320k| } 7277| 310k| JanetCompileLintLevel depLevel = JANET_C_LINT_RELAXED; 7278| 310k| switch (binding.deprecation) { ------------------ | Branch (7278:17): [True: 310k, False: 0] ------------------ 7279| 310k| case JANET_BINDING_DEP_NONE: ------------------ | Branch (7279:13): [True: 310k, False: 0] ------------------ 7280| 310k| break; 7281| 0| case JANET_BINDING_DEP_RELAXED: ------------------ | Branch (7281:13): [True: 0, False: 310k] ------------------ 7282| 0| depLevel = JANET_C_LINT_RELAXED; 7283| 0| break; 7284| 0| case JANET_BINDING_DEP_NORMAL: ------------------ | Branch (7284:13): [True: 0, False: 310k] ------------------ 7285| 0| depLevel = JANET_C_LINT_NORMAL; 7286| 0| break; 7287| 0| case JANET_BINDING_DEP_STRICT: ------------------ | Branch (7287:13): [True: 0, False: 310k] ------------------ 7288| 0| depLevel = JANET_C_LINT_STRICT; 7289| 0| break; 7290| 310k| } 7291| 310k| if (binding.deprecation != JANET_BINDING_DEP_NONE) { ------------------ | Branch (7291:13): [True: 0, False: 310k] ------------------ 7292| 0| janetc_lintf(c, depLevel, "%q is deprecated", janet_wrap_symbol(sym)); ------------------ | | 849| 0|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7293| 0| } 7294| 310k| return ret; 7295| 310k| } 7296| | 7297| | /* Symbol was found */ 7298| 204k|found: 7299| | 7300| | /* Constants can be returned immediately (they are stateless) */ 7301| 204k| if (ret.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) ------------------ | | 1038| 204k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ if (ret.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) ------------------ | | 1041| 204k|#define JANET_SLOT_REF 0x80000 ------------------ | Branch (7301:9): [True: 0, False: 204k] ------------------ 7302| 0| return ret; 7303| | 7304| | /* Unused references and locals shouldn't add captured envs. */ 7305| 204k| if (foundlocal) { ------------------ | Branch (7305:9): [True: 196k, False: 7.81k] ------------------ 7306| 196k| ret.envindex = -1; 7307| 196k| return ret; 7308| 196k| } 7309| 7.81k| if (unused) { ------------------ | Branch (7309:9): [True: 0, False: 7.81k] ------------------ 7310| 0| ret.index = 0; /* we must have at least 1 slot if we are calling resolve in scope */ 7311| 0| ret.envindex = -1; 7312| 0| return ret; 7313| 0| } 7314| | 7315| | /* non-local scope needs to expose its environment */ 7316| 7.81k| JanetScope *original_scope = scope; 7317| 7.81k| pair->keep = 1; 7318| 7.81k| pair->referenced = 1; 7319| 35.0k| while (scope && !(scope->flags & JANET_SCOPE_FUNCTION)) ------------------ | | 1058| 35.0k|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (7319:12): [True: 35.0k, False: 0] | Branch (7319:21): [True: 27.2k, False: 7.81k] ------------------ 7320| 27.2k| scope = scope->parent; 7321| 7.81k| janet_assert(scope, "invalid scopes"); ------------------ | | 389| 7.81k|#define janet_assert(c, m) do { \ | | 390| 7.81k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 7.81k] | | ------------------ | | 391| 7.81k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 7.81k] | | ------------------ ------------------ 7322| 7.81k| scope->flags |= JANET_SCOPE_ENV; ------------------ | | 1059| 7.81k|#define JANET_SCOPE_ENV 2 ------------------ 7323| | 7324| | /* In the function scope, allocate the slot as an upvalue */ 7325| 7.81k| janetc_regalloc_touch(&scope->ua, ret.index); 7326| | 7327| | /* Iterate through child scopes and make sure environment is propagated */ 7328| 7.81k| scope = scope->child; 7329| | 7330| | /* Propagate env up to current scope */ 7331| 7.81k| int32_t envindex = -1; 7332| 49.5k| while (scope) { ------------------ | Branch (7332:12): [True: 41.7k, False: 7.81k] ------------------ 7333| 41.7k| if (scope->flags & JANET_SCOPE_FUNCTION) { ------------------ | | 1058| 41.7k|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (7333:13): [True: 9.03k, False: 32.7k] ------------------ 7334| 9.03k| int32_t j, len; 7335| 9.03k| int scopefound = 0; 7336| | /* Check if scope already has env. If so, break */ 7337| 9.03k| len = janet_v_count(scope->envs); ------------------ | | 759| 9.03k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3.57k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.57k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3.57k, False: 5.46k] | | ------------------ ------------------ 7338| 9.06k| for (j = 0; j < len; j++) { ------------------ | Branch (7338:25): [True: 3.59k, False: 5.47k] ------------------ 7339| 3.59k| if (scope->envs[j].envindex == envindex) { ------------------ | Branch (7339:21): [True: 3.56k, False: 32] ------------------ 7340| 3.56k| scopefound = 1; 7341| 3.56k| envindex = j; 7342| 3.56k| break; 7343| 3.56k| } 7344| 3.59k| } 7345| | /* Add the environment if it is not already referenced */ 7346| 9.03k| if (!scopefound) { ------------------ | Branch (7346:17): [True: 5.47k, False: 3.56k] ------------------ 7347| 5.47k| len = janet_v_count(scope->envs); ------------------ | | 759| 5.47k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 12|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 12|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 12, False: 5.46k] | | ------------------ ------------------ 7348| 5.47k| JanetEnvRef ref; 7349| 5.47k| ref.envindex = envindex; 7350| 5.47k| ref.scope = original_scope; 7351| 5.47k| janet_v_push(scope->envs, ref); ------------------ | | 757| 5.47k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 5.47k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 5.47k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 12|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 12|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 12|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 12|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.46k, False: 12] | | | | | | | Branch (768:50): [True: 12, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 5.47k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 5.47k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 5.47k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7352| 5.47k| envindex = len; 7353| 5.47k| } 7354| 9.03k| } 7355| 41.7k| scope = scope->child; 7356| 41.7k| } 7357| | 7358| 7.81k| ret.envindex = envindex; 7359| 7.81k| return ret; 7360| 7.81k|} janetc_return: 7363| 150k|JanetSlot janetc_return(JanetCompiler *c, JanetSlot s) { 7364| 150k| if (!(s.flags & JANET_SLOT_RETURNED)) { ------------------ | | 1042| 150k|#define JANET_SLOT_RETURNED 0x100000 ------------------ | Branch (7364:9): [True: 149k, False: 627] ------------------ 7365| 149k| if (s.flags & JANET_SLOT_CONSTANT && janet_checktype(s.constant, JANET_NIL)) ------------------ | | 1038| 299k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ if (s.flags & JANET_SLOT_CONSTANT && janet_checktype(s.constant, JANET_NIL)) ------------------ | | 806| 63.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 461, False: 63.4k] | | | Branch (806:6): [Folded, False: 63.9k] | | ------------------ | | 807| 63.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 63.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 63.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 63.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 63.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 63.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7365:13): [True: 63.9k, False: 86.0k] ------------------ 7366| 461| janetc_emit(c, JOP_RETURN_NIL); 7367| 149k| else 7368| 149k| janetc_emit_s(c, JOP_RETURN, s, 0); 7369| 149k| s.flags |= JANET_SLOT_RETURNED; ------------------ | | 1042| 149k|#define JANET_SLOT_RETURNED 0x100000 ------------------ 7370| 149k| } 7371| 150k| return s; 7372| 150k|} janetc_gettarget: 7375| 1.98M|JanetSlot janetc_gettarget(JanetFopts opts) { 7376| 1.98M| JanetSlot slot; 7377| 1.98M| if ((opts.flags & JANET_FOPTS_HINT) && ------------------ | | 1148| 1.98M|#define JANET_FOPTS_HINT 0x20000 ------------------ | Branch (7377:9): [True: 1.86k, False: 1.98M] ------------------ 7378| 1.86k| (opts.hint.envindex < 0) && ------------------ | Branch (7378:13): [True: 1.23k, False: 622] ------------------ 7379| 1.23k| (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) { ------------------ | Branch (7379:14): [True: 690, False: 549] | Branch (7379:38): [True: 690, False: 0] ------------------ 7380| 690| slot = opts.hint; 7381| 1.98M| } else { 7382| 1.98M| slot.envindex = -1; 7383| 1.98M| slot.constant = janet_wrap_nil(); ------------------ | | 831| 1.98M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.98M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.98M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.98M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7384| 1.98M| slot.flags = 0; 7385| 1.98M| slot.index = janetc_allocfar(opts.compiler); 7386| 1.98M| } 7387| 1.98M| return slot; 7388| 1.98M|} janetc_toslots: 7391| 341k|JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len) { 7392| 341k| int32_t i; 7393| 341k| JanetSlot *ret = NULL; 7394| 341k| JanetFopts subopts = janetc_fopts_default(c); 7395| 341k| subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE; ------------------ | | 1150| 341k|#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 ------------------ 7396| 1.79M| for (i = 0; i < len; i++) { ------------------ | Branch (7396:17): [True: 1.44M, False: 341k] ------------------ 7397| | janet_v_push(ret, janetc_value(subopts, vals[i])); ------------------ | | 757| 1.44M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.44M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.44M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.10M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.10M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.10M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.10M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 341k, False: 1.10M] | | | | | | | Branch (768:50): [True: 315k, False: 791k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 656k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.44M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.44M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7398| 1.44M| } 7399| 341k| return ret; 7400| 341k|} janetc_toslotskv: 7403| 36|JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) { 7404| 36| JanetSlot *ret = NULL; 7405| 36| JanetFopts subopts = janetc_fopts_default(c); 7406| 36| subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE; ------------------ | | 1150| 36|#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 ------------------ 7407| 36| const JanetKV *kvs = NULL; 7408| 36| int32_t cap = 0, len = 0; 7409| 36| janet_dictionary_view(ds, &kvs, &len, &cap); 7410| | /* Sort keys for stability of order? */ 7411| 36| int32_t *index_buf; 7412| 36| int32_t index_buf_stack[32]; 7413| 36| int32_t *index_buf_heap = NULL; 7414| 36| if (len < 32) { ------------------ | Branch (7414:9): [True: 33, False: 3] ------------------ 7415| 33| index_buf = index_buf_stack; 7416| 33| } else { 7417| 3| index_buf_heap = janet_smalloc(sizeof(int32_t) * len); 7418| 3| index_buf = index_buf_heap; 7419| 3| } 7420| 36| if (len) janet_sorted_keys(kvs, cap, index_buf); ------------------ | Branch (7420:9): [True: 26, False: 10] ------------------ 7421| 1.96k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (7421:25): [True: 1.93k, False: 36] ------------------ 7422| 1.93k| janet_v_push(ret, janetc_value(subopts, kvs[index_buf[i]].key)); ------------------ | | 757| 1.93k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.93k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.93k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.90k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.90k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.90k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.90k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 26, False: 1.90k] | | | | | | | Branch (768:50): [True: 15, False: 1.88k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 41|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.93k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.93k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7423| 1.93k| janet_v_push(ret, janetc_value(subopts, kvs[index_buf[i]].value)); ------------------ | | 757| 1.93k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.93k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.93k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.93k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.93k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.93k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.93k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 1.93k] | | | | | | | Branch (768:50): [True: 85, False: 1.84k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 85|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.93k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.93k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7424| 1.93k| } 7425| 36| if (index_buf_heap) janet_sfree(index_buf_heap); ------------------ | Branch (7425:9): [True: 3, False: 33] ------------------ 7426| 36| return ret; 7427| 36|} janetc_pushslots: 7432| 1.65M|int32_t janetc_pushslots(JanetCompiler *c, JanetSlot *slots) { 7433| 1.65M| int32_t i; 7434| 1.65M| int32_t count = janet_v_count(slots); ------------------ | | 759| 1.65M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.65M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.65M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.65M, False: 99] | | ------------------ ------------------ 7435| 1.65M| int32_t min_arity = 0; 7436| 1.65M| int has_splice = 0; 7437| 3.66M| for (i = 0; i < count;) { ------------------ | Branch (7437:17): [True: 2.00M, False: 1.65M] ------------------ 7438| 2.00M| if (slots[i].flags & JANET_SLOT_SPLICED) { ------------------ | | 1046| 2.00M|#define JANET_SLOT_SPLICED 0x1000000 ------------------ | Branch (7438:13): [True: 19.0k, False: 1.99M] ------------------ 7439| 19.0k| janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i], 0); 7440| 19.0k| i++; 7441| 19.0k| has_splice = 1; 7442| 1.99M| } else if (i + 1 == count) { ------------------ | Branch (7442:20): [True: 36.0k, False: 1.95M] ------------------ 7443| 36.0k| janetc_emit_s(c, JOP_PUSH, slots[i], 0); 7444| 36.0k| i++; 7445| 36.0k| min_arity++; 7446| 1.95M| } else if (slots[i + 1].flags & JANET_SLOT_SPLICED) { ------------------ | | 1046| 1.95M|#define JANET_SLOT_SPLICED 0x1000000 ------------------ | Branch (7446:20): [True: 85.1k, False: 1.86M] ------------------ 7447| 85.1k| janetc_emit_s(c, JOP_PUSH, slots[i], 0); 7448| 85.1k| janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 1], 0); 7449| 85.1k| i += 2; 7450| 85.1k| min_arity++; 7451| 85.1k| has_splice = 1; 7452| 1.86M| } else if (i + 2 == count) { ------------------ | Branch (7452:20): [True: 1.61M, False: 250k] ------------------ 7453| 1.61M| janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0); 7454| 1.61M| i += 2; 7455| 1.61M| min_arity += 2; 7456| 1.61M| } else if (slots[i + 2].flags & JANET_SLOT_SPLICED) { ------------------ | | 1046| 250k|#define JANET_SLOT_SPLICED 0x1000000 ------------------ | Branch (7456:20): [True: 3.18k, False: 247k] ------------------ 7457| 3.18k| janetc_emit_ss(c, JOP_PUSH_2, slots[i], slots[i + 1], 0); 7458| 3.18k| janetc_emit_s(c, JOP_PUSH_ARRAY, slots[i + 2], 0); 7459| 3.18k| i += 3; 7460| 3.18k| min_arity += 2; 7461| 3.18k| has_splice = 1; 7462| 247k| } else { 7463| 247k| janetc_emit_sss(c, JOP_PUSH_3, slots[i], slots[i + 1], slots[i + 2], 0); 7464| 247k| i += 3; 7465| 247k| min_arity += 3; 7466| 247k| } 7467| 2.00M| } 7468| 1.65M| return has_splice ? (-1 - min_arity) : min_arity; ------------------ | Branch (7468:12): [True: 152, False: 1.65M] ------------------ 7469| 1.65M|} janetc_freeslots: 7482| 1.84M|void janetc_freeslots(JanetCompiler *c, JanetSlot *slots) { 7483| 1.84M| int32_t i; 7484| 6.52M| for (i = 0; i < janet_v_count(slots); i++) { ------------------ | | 759| 6.52M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 6.52M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 6.52M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 6.52M, False: 404] | | ------------------ ------------------ | Branch (7484:17): [True: 4.67M, False: 1.84M] ------------------ 7485| 4.67M| janetc_freeslot(c, slots[i]); 7486| 4.67M| } 7487| | janet_v_free(slots); ------------------ | | 756| 1.84M|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 1.84M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 1.84M, False: 404] | | ------------------ ------------------ 7488| 1.84M|} janetc_throwaway: 7493| 256|void janetc_throwaway(JanetFopts opts, Janet x) { 7494| 256| JanetCompiler *c = opts.compiler; 7495| 256| JanetScope unusedScope; 7496| 256| int32_t bufstart = janet_v_count(c->buffer); ------------------ | | 759| 256|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 175|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 175|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 175, False: 81] | | ------------------ ------------------ 7497| 256| int32_t mapbufstart = janet_v_count(c->mapbuffer); ------------------ | | 759| 256|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 175|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 175|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 175, False: 81] | | ------------------ ------------------ 7498| 256| janetc_scope(&unusedScope, c, JANET_SCOPE_UNUSED, "unused"); ------------------ | | 1061| 256|#define JANET_SCOPE_UNUSED 8 ------------------ 7499| 256| janetc_value(opts, x); 7500| 256| janetc_lintf(c, JANET_C_LINT_STRICT, "dead code, consider removing %.4q", x); 7501| 256| janetc_popscope(c); 7502| 256| if (c->buffer) { ------------------ | Branch (7502:9): [True: 175, False: 81] ------------------ 7503| 175| janet_v__cnt(c->buffer) = bufstart; ------------------ | | 766| 175|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 175|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ 7504| 175| if (c->mapbuffer) ------------------ | Branch (7504:13): [True: 175, False: 0] ------------------ 7505| 175| janet_v__cnt(c->mapbuffer) = mapbufstart; ------------------ | | 766| 175|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 175|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ 7506| 175| } 7507| 256|} janetc_value: 7880| 3.03M|JanetSlot janetc_value(JanetFopts opts, Janet x) { 7881| 3.03M| JanetSlot ret; 7882| 3.03M| JanetCompiler *c = opts.compiler; 7883| 3.03M| JanetSourceMapping last_mapping = c->current_mapping; 7884| 3.03M| c->recursion_guard--; 7885| | 7886| | /* Guard against previous errors and unbounded recursion */ 7887| 3.03M| if (c->result.status == JANET_COMPILE_ERROR) return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 726k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 726k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 726k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 726k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7887:9): [True: 726k, False: 2.31M] ------------------ 7888| 2.31M| if (c->recursion_guard <= 0) { ------------------ | Branch (7888:9): [True: 28, False: 2.31M] ------------------ 7889| 28| janetc_cerror(c, "recursed too deeply"); 7890| 28| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 28|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 28| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 28|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 28|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7891| 28| } 7892| | 7893| | /* Macro expand. Also gets possible special form and 7894| | * refines source mapping cursor if possible. */ 7895| 2.31M| const JanetSpecial *spec = NULL; 7896| 2.31M| int macroi = JANET_MAX_MACRO_EXPAND; ------------------ | | 302| 2.31M|#define JANET_MAX_MACRO_EXPAND 200 ------------------ 7897| 2.37M| while (macroi && ------------------ | Branch (7897:12): [True: 2.37M, False: 0] ------------------ 7898| 2.37M| c->result.status != JANET_COMPILE_ERROR && ------------------ | Branch (7898:13): [True: 2.37M, False: 0] ------------------ 7899| 2.37M| macroexpand1(c, x, &x, &spec)) ------------------ | Branch (7899:13): [True: 65.9k, False: 2.31M] ------------------ 7900| 65.9k| macroi--; 7901| 2.31M| if (macroi == 0) { ------------------ | Branch (7901:9): [True: 0, False: 2.31M] ------------------ 7902| 0| janetc_cerror(c, "recursed too deeply in macro expansion"); 7903| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7904| 0| } 7905| | 7906| | /* Special forms */ 7907| 2.31M| if (spec) { ------------------ | Branch (7907:9): [True: 506k, False: 1.80M] ------------------ 7908| 506k| const Janet *tup = janet_unwrap_tuple(x); ------------------ | | 858| 506k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 7909| 506k| ret = spec->compile(opts, janet_tuple_length(tup) - 1, tup + 1); ------------------ | | 1802| 506k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 506k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 7910| 1.80M| } else { 7911| 1.80M| switch (janet_type(x)) { ------------------ | | 795| 1.80M| (isnan((x).number) \ | | 796| 1.80M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 1.80M| : JANET_NUMBER) ------------------ | Branch (7911:17): [True: 1.47M, False: 326k] ------------------ 7912| 343k| case JANET_TUPLE: { ------------------ | Branch (7912:13): [True: 343k, False: 1.45M] ------------------ 7913| 343k| JanetFopts subopts = janetc_fopts_default(c); 7914| 343k| const Janet *tup = janet_unwrap_tuple(x); ------------------ | | 858| 343k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 7915| | /* Empty tuple is tuple literal */ 7916| 343k| if (janet_tuple_length(tup) == 0) { ------------------ | | 1802| 343k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 343k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (7916:21): [True: 1.81k, False: 341k] ------------------ 7917| 1.81k| ret = janetc_cslot(janet_wrap_tuple(janet_tuple_n(NULL, 0))); ------------------ | | 843| 1.81k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 1.81k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.81k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.81k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7918| 341k| } else if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { /* [] tuples are not function call */ ------------------ | | 1806| 341k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 341k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ } else if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { /* [] tuples are not function call */ ------------------ | | 1798| 341k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (7918:28): [True: 244, False: 341k] ------------------ 7919| 244| ret = janetc_tuple(opts, x); 7920| 341k| } else { 7921| | /* Function calls */ 7922| 341k| JanetSlot head = janetc_value(subopts, tup[0]); 7923| 341k| ret = janetc_call(opts, janetc_toslots(c, tup + 1, janet_tuple_length(tup) - 1), head, tup); ------------------ | | 1802| 341k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 341k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 7924| 341k| janetc_freeslot(c, head); 7925| 341k| } 7926| 343k| ret.flags &= ~JANET_SLOT_SPLICED; ------------------ | | 1046| 343k|#define JANET_SLOT_SPLICED 0x1000000 ------------------ 7927| 343k| } 7928| 343k| break; 7929| | /* Data Constructors */ 7930| 522k| case JANET_SYMBOL: ------------------ | Branch (7930:13): [True: 522k, False: 1.28M] ------------------ 7931| 522k| ret = janetc_resolve(c, janet_unwrap_symbol(x)); ------------------ | | 864| 522k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 7932| 522k| break; 7933| 1| case JANET_ARRAY: ------------------ | Branch (7933:13): [True: 1, False: 1.80M] ------------------ 7934| 1| ret = janetc_array(opts, x); 7935| 1| break; 7936| 23| case JANET_STRUCT: ------------------ | Branch (7936:13): [True: 23, False: 1.80M] ------------------ 7937| 23| ret = janetc_tablector(opts, x, JOP_MAKE_STRUCT); 7938| 23| break; 7939| 13| case JANET_TABLE: ------------------ | Branch (7939:13): [True: 13, False: 1.80M] ------------------ 7940| 13| ret = janetc_tablector(opts, x, JOP_MAKE_TABLE); 7941| 13| break; 7942| 35| case JANET_BUFFER: ------------------ | Branch (7942:13): [True: 35, False: 1.80M] ------------------ 7943| 35| ret = janetc_bufferctor(opts, x); 7944| 35| break; 7945| 937k| default: ------------------ | Branch (7945:13): [True: 937k, False: 866k] ------------------ 7946| 937k| ret = janetc_cslot(x); 7947| 937k| break; 7948| 1.80M| } 7949| 1.80M| } 7950| | 7951| 2.31M| if (c->result.status == JANET_COMPILE_ERROR) ------------------ | Branch (7951:9): [True: 97.5k, False: 2.21M] ------------------ 7952| 97.5k| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 97.5k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 97.5k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 97.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 97.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7953| 2.21M| if (opts.flags & JANET_FOPTS_TAIL) ------------------ | | 1147| 2.21M|#define JANET_FOPTS_TAIL 0x10000 ------------------ | Branch (7953:9): [True: 150k, False: 2.06M] ------------------ 7954| 150k| ret = janetc_return(c, ret); 7955| 2.21M| if (opts.flags & JANET_FOPTS_HINT) { ------------------ | | 1148| 2.21M|#define JANET_FOPTS_HINT 0x20000 ------------------ | Branch (7955:9): [True: 1.86k, False: 2.21M] ------------------ 7956| 1.86k| janetc_copy(c, opts.hint, ret); 7957| 1.86k| ret = opts.hint; 7958| 1.86k| } 7959| 2.21M| c->current_mapping = last_mapping; 7960| 2.21M| c->recursion_guard++; 7961| 2.21M| return ret; 7962| 2.31M|} janet_def_addflags: 7965| 149k|void janet_def_addflags(JanetFuncDef *def) { 7966| 149k| int32_t set_flags = 0; 7967| 149k| int32_t unset_flags = 0; 7968| | /* pos checks */ 7969| 149k| if (def->name) set_flags |= JANET_FUNCDEF_FLAG_HASNAME; ------------------ | | 1100| 148k|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (7969:9): [True: 148k, False: 1.80k] ------------------ 7970| 149k| if (def->source) set_flags |= JANET_FUNCDEF_FLAG_HASSOURCE; ------------------ | | 1101| 149k|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (7970:9): [True: 149k, False: 0] ------------------ 7971| 149k| if (def->defs) set_flags |= JANET_FUNCDEF_FLAG_HASDEFS; ------------------ | | 1102| 80.2k|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (7971:9): [True: 80.2k, False: 69.6k] ------------------ 7972| 149k| if (def->environments) set_flags |= JANET_FUNCDEF_FLAG_HASENVS; ------------------ | | 1103| 149k|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (7972:9): [True: 149k, False: 0] ------------------ 7973| 149k| if (def->sourcemap) set_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP; ------------------ | | 1104| 149k|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (7973:9): [True: 149k, False: 0] ------------------ 7974| 149k| if (def->closure_bitset) set_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET; ------------------ | | 1106| 713|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (7974:9): [True: 713, False: 149k] ------------------ 7975| 149k| if (def->named_args_count) set_flags |= JANET_FUNCDEF_FLAG_NAMEDARGS; ------------------ | | 1107| 0|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (7975:9): [True: 0, False: 149k] ------------------ 7976| | /* negative checks */ 7977| 149k| if (!def->name) unset_flags |= JANET_FUNCDEF_FLAG_HASNAME; ------------------ | | 1100| 1.80k|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (7977:9): [True: 1.80k, False: 148k] ------------------ 7978| 149k| if (!def->source) unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCE; ------------------ | | 1101| 0|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (7978:9): [True: 0, False: 149k] ------------------ 7979| 149k| if (!def->defs) unset_flags |= JANET_FUNCDEF_FLAG_HASDEFS; ------------------ | | 1102| 69.6k|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (7979:9): [True: 69.6k, False: 80.2k] ------------------ 7980| 149k| if (!def->environments) unset_flags |= JANET_FUNCDEF_FLAG_HASENVS; ------------------ | | 1103| 0|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (7980:9): [True: 0, False: 149k] ------------------ 7981| 149k| if (!def->sourcemap) unset_flags |= JANET_FUNCDEF_FLAG_HASSOURCEMAP; ------------------ | | 1104| 0|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (7981:9): [True: 0, False: 149k] ------------------ 7982| 149k| if (!def->closure_bitset) unset_flags |= JANET_FUNCDEF_FLAG_HASCLOBITSET; ------------------ | | 1106| 149k|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (7982:9): [True: 149k, False: 713] ------------------ 7983| 149k| if (!def->named_args_count) unset_flags |= JANET_FUNCDEF_FLAG_NAMEDARGS; ------------------ | | 1107| 149k|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (7983:9): [True: 149k, False: 0] ------------------ 7984| | /* Update flags */ 7985| 149k| def->flags |= set_flags; 7986| 149k| def->flags &= ~unset_flags; 7987| 149k|} janetc_pop_funcdef: 7992| 149k|JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c, JanetString name) { 7993| 149k| JanetScope *scope = c->scope; 7994| 149k| JanetFuncDef *def = janet_funcdef_alloc(); 7995| 149k| def->slotcount = scope->ra.max + 1; 7996| | 7997| 149k| janet_assert(scope->flags & JANET_SCOPE_FUNCTION, "expected function scope"); ------------------ | | 389| 149k|#define janet_assert(c, m) do { \ | | 390| 149k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 149k] | | ------------------ | | 391| 149k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 149k] | | ------------------ ------------------ 7998| | 7999| | /* Copy envs */ 8000| 149k| def->environments_length = janet_v_count(scope->envs); ------------------ | | 759| 149k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 5.42k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 5.42k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 5.42k, False: 144k] | | ------------------ ------------------ 8001| 149k| def->environments = janet_malloc(sizeof(int32_t) * def->environments_length); ------------------ | | 2406| 149k|#define janet_malloc(X) malloc((X)) ------------------ 8002| 155k| for (int32_t i = 0; i < def->environments_length; i++) { ------------------ | Branch (8002:25): [True: 5.44k, False: 149k] ------------------ 8003| 5.44k| def->environments[i] = scope->envs[i].envindex; 8004| 5.44k| } 8005| | 8006| 149k| def->constants_length = janet_v_count(scope->consts); ------------------ | | 759| 149k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 56.6k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 56.6k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 56.6k, False: 93.2k] | | ------------------ ------------------ 8007| 149k| def->constants = janet_v_flatten(scope->consts); ------------------ | | 762| 149k|#define janet_v_flatten(v) (janet_v_flattenmem((v), sizeof(*(v)))) ------------------ 8008| | 8009| 149k| def->defs_length = janet_v_count(scope->defs); ------------------ | | 759| 149k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 80.2k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 80.2k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 80.2k, False: 69.6k] | | ------------------ ------------------ 8010| 149k| def->defs = janet_v_flatten(scope->defs); ------------------ | | 762| 149k|#define janet_v_flatten(v) (janet_v_flattenmem((v), sizeof(*(v)))) ------------------ 8011| | 8012| | /* Copy bytecode (only last chunk) */ 8013| 149k| def->bytecode_length = janet_v_count(c->buffer) - scope->bytecode_start; ------------------ | | 759| 149k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 149k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 149k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 149k, False: 0] | | ------------------ ------------------ 8014| 149k| if (def->bytecode_length) { ------------------ | Branch (8014:9): [True: 149k, False: 0] ------------------ 8015| 149k| size_t s = sizeof(int32_t) * (size_t) def->bytecode_length; 8016| 149k| def->bytecode = janet_malloc(s); ------------------ | | 2406| 149k|#define janet_malloc(X) malloc((X)) ------------------ 8017| 149k| if (NULL == def->bytecode) { ------------------ | Branch (8017:13): [True: 0, False: 149k] ------------------ 8018| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 8019| 0| } 8020| 149k| safe_memcpy(def->bytecode, c->buffer + scope->bytecode_start, s); 8021| 149k| janet_v__cnt(c->buffer) = scope->bytecode_start; ------------------ | | 766| 149k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 149k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ 8022| 149k| if (NULL != c->mapbuffer && c->source) { ------------------ | Branch (8022:13): [True: 149k, False: 0] | Branch (8022:37): [True: 149k, False: 0] ------------------ 8023| 149k| size_t s = sizeof(JanetSourceMapping) * (size_t) def->bytecode_length; 8024| 149k| def->sourcemap = janet_malloc(s); ------------------ | | 2406| 149k|#define janet_malloc(X) malloc((X)) ------------------ 8025| 149k| if (NULL == def->sourcemap) { ------------------ | Branch (8025:17): [True: 0, False: 149k] ------------------ 8026| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 8027| 0| } 8028| 149k| safe_memcpy(def->sourcemap, c->mapbuffer + scope->bytecode_start, s); 8029| 149k| janet_v__cnt(c->mapbuffer) = scope->bytecode_start; ------------------ | | 766| 149k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 149k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ 8030| 149k| } 8031| 149k| } 8032| | 8033| | /* Get source from parser */ 8034| 149k| def->source = c->source; 8035| | 8036| 149k| def->arity = 0; 8037| 149k| def->min_arity = 0; 8038| 149k| def->flags = 0; 8039| 149k| if (scope->flags & JANET_SCOPE_ENV) { ------------------ | | 1059| 149k|#define JANET_SCOPE_ENV 2 ------------------ | Branch (8039:9): [True: 713, False: 149k] ------------------ 8040| 713| def->flags |= JANET_FUNCDEF_FLAG_NEEDSENV; ------------------ | | 1098| 713|#define JANET_FUNCDEF_FLAG_NEEDSENV 0x20000 ------------------ 8041| 713| } 8042| | 8043| | /* Copy upvalue bitset */ 8044| 149k| if (scope->ua.count) { ------------------ | Branch (8044:9): [True: 713, False: 149k] ------------------ 8045| | /* Number of u32s we need to create a bitmask for all slots */ 8046| 713| int32_t slotchunks = ((def->slotcount - 1) >> 5) + 1; 8047| | /* numchunks is min of slotchunks and scope->ua.count */ 8048| 713| int32_t numchunks = slotchunks > scope->ua.count ? scope->ua.count : slotchunks; ------------------ | Branch (8048:29): [True: 0, False: 713] ------------------ 8049| 713| uint32_t *chunks = janet_calloc(slotchunks, sizeof(uint32_t)); ------------------ | | 2412| 713|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 8050| 713| if (NULL == chunks) { ------------------ | Branch (8050:13): [True: 0, False: 713] ------------------ 8051| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 8052| 0| } 8053| 713| memcpy(chunks, scope->ua.chunks, sizeof(uint32_t) * numchunks); 8054| | /* fprintf(stderr, "slot chunks: %d, scope->ua.count: %d, numchunks: %d\n", slotchunks, scope->ua.count, numchunks); */ 8055| | /* Register allocator preallocates some registers [240-255, high 16 bits of chunk index 7], we can ignore those. */ 8056| 713| if (scope->ua.count > 7 && slotchunks > 7) chunks[7] &= 0xFFFFU; ------------------ | Branch (8056:13): [True: 520, False: 193] | Branch (8056:36): [True: 260, False: 260] ------------------ 8057| 713| def->closure_bitset = chunks; 8058| 713| } 8059| | 8060| | /* Capture symbol to local mapping */ 8061| 149k| JanetSymbolMap *locals = NULL; 8062| | 8063| | /* Symbol -> upvalue mapping */ 8064| 149k| JanetScope *top = c->scope; 8065| 505k| while (top->parent) top = top->parent; ------------------ | Branch (8065:12): [True: 355k, False: 149k] ------------------ 8066| 654k| for (JanetScope *s = top; s != NULL; s = s->child) { ------------------ | Branch (8066:31): [True: 505k, False: 149k] ------------------ 8067| 556k| for (int32_t j = 0; j < janet_v_count(scope->envs); j++) { ------------------ | | 759| 556k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 102k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 102k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 102k, False: 453k] | | ------------------ ------------------ | Branch (8067:29): [True: 51.4k, False: 505k] ------------------ 8068| 51.4k| JanetEnvRef ref = scope->envs[j]; 8069| 51.4k| JanetScope *upscope = ref.scope; 8070| 51.4k| if (upscope != s) continue; ------------------ | Branch (8070:17): [True: 45.9k, False: 5.44k] ------------------ 8071| 2.16M| for (int32_t i = 0; i < janet_v_count(upscope->syms); i++) { ------------------ | | 759| 2.16M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.16M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.16M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.16M, False: 0] | | ------------------ ------------------ | Branch (8071:33): [True: 2.15M, False: 5.44k] ------------------ 8072| 2.15M| SymPair pair = upscope->syms[i]; 8073| 2.15M| if (pair.sym2) { ------------------ | Branch (8073:21): [True: 2.14M, False: 8.57k] ------------------ 8074| 2.14M| JanetSymbolMap jsm; 8075| 2.14M| jsm.birth_pc = UINT32_MAX; 8076| 2.14M| jsm.death_pc = j; /* Use death_pc to encode environment index */ 8077| 2.14M| jsm.slot_index = pair.slot.index; 8078| 2.14M| jsm.symbol = pair.sym2; 8079| 2.14M| janet_v_push(locals, jsm); ------------------ | | 757| 2.14M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 2.14M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 2.14M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 2.14M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.14M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 2.14M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 2.14M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 5.42k, False: 2.14M] | | | | | | | Branch (768:50): [True: 21.9k, False: 2.12M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 27.3k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 2.14M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.14M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 8080| 2.14M| } 8081| 2.15M| } 8082| 5.44k| } 8083| 505k| } 8084| | 8085| | /* Symbol -> slot mapping */ 8086| 442k| for (int32_t i = 0; i < janet_v_count(scope->syms); i++) { ------------------ | | 759| 442k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 296k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 296k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 296k, False: 145k] | | ------------------ ------------------ | Branch (8086:25): [True: 292k, False: 149k] ------------------ 8087| 292k| SymPair pair = scope->syms[i]; 8088| 292k| if (pair.sym2) { ------------------ | Branch (8088:13): [True: 291k, False: 836] ------------------ 8089| 291k| JanetSymbolMap jsm; 8090| | /* Check for unused symbols */ 8091| 291k| if (pair.referenced == 0 && pair.sym) { ------------------ | Branch (8091:17): [True: 288k, False: 3.15k] | Branch (8091:41): [True: 288k, False: 62] ------------------ 8092| 288k| janetc_lintf(c, JANET_C_LINT_STRICT, "binding %q is unused", janet_wrap_symbol(pair.sym)); ------------------ | | 849| 288k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 288k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 288k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 288k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8093| 288k| } 8094| 291k| if (pair.death_pc == UINT32_MAX) { ------------------ | Branch (8094:17): [True: 291k, False: 685] ------------------ 8095| 291k| jsm.death_pc = def->bytecode_length; 8096| 291k| } else { 8097| 685| jsm.death_pc = pair.death_pc - scope->bytecode_start; 8098| 685| } 8099| | /* Handle birth_pc == 0 correctly */ 8100| 291k| if ((uint32_t) scope->bytecode_start > pair.birth_pc) { ------------------ | Branch (8100:17): [True: 3.52k, False: 288k] ------------------ 8101| 3.52k| jsm.birth_pc = 0; 8102| 288k| } else { 8103| 288k| jsm.birth_pc = pair.birth_pc - scope->bytecode_start; 8104| 288k| } 8105| 291k| janet_assert(jsm.birth_pc <= jsm.death_pc, "birth pc after death pc"); ------------------ | | 389| 291k|#define janet_assert(c, m) do { \ | | 390| 291k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 291k] | | ------------------ | | 391| 291k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 291k] | | ------------------ ------------------ 8106| 291k| janet_assert(jsm.birth_pc < (uint32_t) def->bytecode_length, "bad birth pc"); ------------------ | | 389| 291k|#define janet_assert(c, m) do { \ | | 390| 291k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 291k] | | ------------------ | | 391| 291k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 291k] | | ------------------ ------------------ 8107| 291k| janet_assert(jsm.death_pc <= (uint32_t) def->bytecode_length, "bad death pc"); ------------------ | | 389| 291k|#define janet_assert(c, m) do { \ | | 390| 291k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 291k] | | ------------------ | | 391| 291k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 291k] | | ------------------ ------------------ 8108| 291k| jsm.slot_index = pair.slot.index; 8109| 291k| jsm.symbol = pair.sym2; 8110| 291k| janet_v_push(locals, jsm); ------------------ | | 757| 291k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 291k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 291k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 291k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 291k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 291k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 291k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 579, False: 291k] | | | | | | | Branch (768:50): [True: 8.59k, False: 282k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 9.17k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 291k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 291k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 8111| 291k| } 8112| 292k| } 8113| 149k| def->symbolmap_length = janet_v_count(locals); ------------------ | | 759| 149k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 6.00k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 6.00k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 6.00k, False: 143k] | | ------------------ ------------------ 8114| 149k| def->symbolmap = janet_v_flatten(locals); ------------------ | | 762| 149k|#define janet_v_flatten(v) (janet_v_flattenmem((v), sizeof(*(v)))) ------------------ 8115| 149k| if (def->symbolmap_length) def->flags |= JANET_FUNCDEF_FLAG_HASSYMBOLMAP; ------------------ | | 1099| 6.00k|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (8115:9): [True: 6.00k, False: 143k] ------------------ 8116| | 8117| | /* Pop the scope */ 8118| 149k| janetc_popscope(c); 8119| | 8120| | /* Add a name _before_ optimization for debugging */ 8121| 149k| def->name = name; 8122| | 8123| |#ifdef JANET_DEBUG 8124| | janet_verify(def); 8125| |#endif 8126| | 8127| 149k| return def; 8128| 149k|} janet_compile_lint: 8167| 57.2k| JanetTable *env, const uint8_t *where, JanetArray *lints) { 8168| 57.2k| JanetCompiler c; 8169| 57.2k| JanetScope rootscope; 8170| 57.2k| JanetFopts fopts; 8171| | 8172| 57.2k| janetc_init(&c, env, where, lints); 8173| | 8174| | /* Push a function scope */ 8175| 57.2k| janetc_scope(&rootscope, &c, JANET_SCOPE_FUNCTION | JANET_SCOPE_TOP, "root"); ------------------ | | 1058| 57.2k|#define JANET_SCOPE_FUNCTION 1 ------------------ janetc_scope(&rootscope, &c, JANET_SCOPE_FUNCTION | JANET_SCOPE_TOP, "root"); ------------------ | | 1060| 57.2k|#define JANET_SCOPE_TOP 4 ------------------ 8176| | 8177| | /* Set initial form options */ 8178| 57.2k| fopts.compiler = &c; 8179| 57.2k| fopts.flags = JANET_FOPTS_TAIL | JANET_SLOTTYPE_ANY; ------------------ | | 1147| 57.2k|#define JANET_FOPTS_TAIL 0x10000 ------------------ fopts.flags = JANET_FOPTS_TAIL | JANET_SLOTTYPE_ANY; ------------------ | | 1048| 57.2k|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ 8180| 57.2k| fopts.hint = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 57.2k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 57.2k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 57.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 57.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8181| | 8182| | /* Compile the value */ 8183| 57.2k| janetc_value(fopts, source); 8184| | 8185| 57.2k| if (c.result.status == JANET_COMPILE_OK) { ------------------ | Branch (8185:9): [True: 17.8k, False: 39.3k] ------------------ 8186| 17.8k| JanetFuncDef *def = janetc_pop_funcdef(&c, janet_cstring("thunk")); 8187| 17.8k| janet_def_addflags(def); 8188| 17.8k| janet_bytecode_optimize(def, c.optimize); 8189| 17.8k| c.result.funcdef = def; 8190| 39.3k| } else { 8191| 39.3k| c.result.error_mapping = c.current_mapping; 8192| 39.3k| janetc_popscope(&c); 8193| 39.3k| } 8194| | 8195| 57.2k| janetc_deinit(&c); 8196| | 8197| 57.2k| return c.result; 8198| 57.2k|} janet_compile: 8200| 57.2k|JanetCompileResult janet_compile(Janet source, JanetTable *env, const uint8_t *where) { 8201| | return janet_compile_lint(source, env, where, NULL); 8202| 57.2k|} janet_lib_compile: 8256| 264|void janet_lib_compile(JanetTable *env) { 8257| 264| JanetRegExt cfuns[] = { 8258| 264| JANET_CORE_REG("compile", cfun_compile), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 8259| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 8260| 264| }; 8261| | janet_core_cfuns_ext(env, NULL, cfuns); 8262| 264|} janet_core_dyn: 8532| 758k| "returns `dflt` (or nil).") { 8533| 758k| janet_arity(argc, 1, 2); 8534| 758k| Janet value; 8535| 758k| if (janet_vm.fiber->env) { ------------------ | Branch (8535:9): [True: 758k, False: 0] ------------------ 8536| 758k| value = janet_table_get(janet_vm.fiber->env, argv[0]); 8537| 758k| } else { 8538| 0| value = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8539| 0| } 8540| 758k| if (argc == 2 && janet_checktype(value, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (8540:9): [True: 0, False: 758k] ------------------ 8541| 0| return argv[1]; 8542| 0| } 8543| 758k| return value; 8544| 758k|} janet_core_setdyn: 8548| 286k| "Set a dynamic binding for `key` to `val`. Returns `val`.") { 8549| 286k| janet_fixarity(argc, 2); 8550| 286k| if (!janet_vm.fiber->env) { ------------------ | Branch (8550:9): [True: 0, False: 286k] ------------------ 8551| 0| janet_vm.fiber->env = janet_table(2); 8552| 0| } 8553| 286k| janet_table_put(janet_vm.fiber->env, argv[0], argv[1]); 8554| 286k| return argv[1]; 8555| 286k|} janet_core_string: 8602| 31| "Returns the new string.") { 8603| 31| JanetBuffer *b = janet_buffer(0); 8604| 122| for (int32_t i = 0; i < argc; ++i) ------------------ | Branch (8604:25): [True: 91, False: 31] ------------------ 8605| 91| janet_to_string_b(b, argv[i]); 8606| 31| return janet_stringv(b->data, b->count); ------------------ | | 1827| 31|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 31|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 31| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 31|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 31|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8607| 31|} janet_core_symbol: 8613| 1.19k| "Returns the new symbol.") { 8614| 1.19k| JanetBuffer *b = janet_buffer(0); 8615| 4.50k| for (int32_t i = 0; i < argc; ++i) ------------------ | Branch (8615:25): [True: 3.31k, False: 1.19k] ------------------ 8616| 3.31k| janet_to_string_b(b, argv[i]); 8617| 1.19k| return janet_symbolv(b->data, b->count); ------------------ | | 1836| 1.19k|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 1.19k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.19k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.19k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.19k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8618| 1.19k|} janet_core_buffer: 8635| 29| "Returns the new buffer.") { 8636| 29| JanetBuffer *b = janet_buffer(0); 8637| 87| for (int32_t i = 0; i < argc; ++i) ------------------ | Branch (8637:25): [True: 58, False: 29] ------------------ 8638| 58| janet_to_string_b(b, argv[i]); 8639| 29| return janet_wrap_buffer(b); ------------------ | | 847| 29|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 29| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 29|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 29|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8640| 29|} janet_core_scannumber: 8655| 435| "radix specifier is expected at the beginning of the number.") { 8656| 435| double number; 8657| 435| janet_arity(argc, 1, 2); 8658| 435| JanetByteView view = janet_getbytes(argv, 0); 8659| 435| int32_t base = janet_optinteger(argv, argc, 1, 0); 8660| 435| int valid = base == 0 || (base >= 2 && base <= 36); ------------------ | Branch (8660:17): [True: 435, False: 0] | Branch (8660:31): [True: 0, False: 0] | Branch (8660:44): [True: 0, False: 0] ------------------ 8661| 435| if (!valid) { ------------------ | Branch (8661:9): [True: 0, False: 435] ------------------ 8662| 0| janet_panicf("expected base between 2 and 36, got %d", base); 8663| 0| } 8664| 435| if (janet_scan_number_base(view.bytes, view.len, base, &number)) ------------------ | Branch (8664:9): [True: 434, False: 1] ------------------ 8665| 434| return janet_wrap_nil(); ------------------ | | 831| 434|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 434| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 434|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 434|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8666| 1| return janet_wrap_number(number); ------------------ | | 835| 1|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 8667| 435|} janet_core_tuple: 8671| 751k| "Creates and returns a tuple that contains values from `xs`.") { 8672| 751k| return janet_wrap_tuple(janet_tuple_n(argv, argc)); ------------------ | | 843| 751k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 751k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 751k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 751k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8673| 751k|} janet_core_struct: 8796| 30| "thrown.") { 8797| 30| int32_t i; 8798| 30| if (argc & 1) { ------------------ | Branch (8798:9): [True: 0, False: 30] ------------------ 8799| 0| janet_panic("expected even number of arguments"); 8800| 0| } 8801| 30| JanetKV *st = janet_struct_begin(argc >> 1); 8802| 72| for (i = 0; i < argc; i += 2) { ------------------ | Branch (8802:17): [True: 42, False: 30] ------------------ 8803| 42| janet_struct_put(st, argv[i], argv[i + 1]); 8804| 42| } 8805| 30| return janet_wrap_struct(janet_struct_end(st)); ------------------ | | 842| 30|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 30| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 30|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 30|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8806| 30|} janet_core_gensym: 8812| 598k| "it can be used in macros to generate automatic bindings.") { 8813| 598k| (void) argv; 8814| 598k| janet_fixarity(argc, 0); 8815| 598k| return janet_wrap_symbol(janet_symbol_gen()); ------------------ | | 849| 598k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 598k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 598k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 598k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8816| 598k|} janet_core_type: 8871| 14.8M| "or another keyword for an abstract type.") { 8872| 14.8M| janet_fixarity(argc, 1); 8873| 14.8M| JanetType t = janet_type(argv[0]); ------------------ | | 795| 14.8M| (isnan((x).number) \ | | 796| 14.8M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 14.8M| : JANET_NUMBER) ------------------ | Branch (8873:19): [True: 14.7M, False: 114k] ------------------ 8874| 14.8M| if (t == JANET_ABSTRACT) { ------------------ | Branch (8874:9): [True: 713, False: 14.8M] ------------------ 8875| 713| return janet_ckeywordv(janet_abstract_type(janet_unwrap_abstract(argv[0]))->name); ------------------ | | 1843| 713|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 713|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 713| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 713|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 713|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8876| 14.8M| } else { 8877| 14.8M| return janet_ckeywordv(janet_type_names[t]); ------------------ | | 1843| 14.8M|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 14.8M|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 14.8M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 14.8M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 14.8M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8878| 14.8M| } 8879| 14.8M|} janet_core_check_nat: 8950| 1| "Check if x can be exactly represented as a non-negative 32 bit signed two's complement integer.") { 8951| 1| janet_fixarity(argc, 1); 8952| 1| if (!janet_checkint(argv[0])) return janet_wrap_false(); ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (8952:9): [True: 0, False: 1] ------------------ 8953| 1| return janet_wrap_boolean(janet_unwrap_integer(argv[0]) >= 0); ------------------ | | 834| 1|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 1| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8954| 1|} janet_core_is_indexed: 8965| 2| "Check if x is an array or tuple.") { 8966| 2| janet_fixarity(argc, 1); 8967| 2| return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_INDEXED)); ------------------ | | 834| 2|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 4| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (822:51): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 8968| 2|} janet_core_memcmp: 9019| 2.76k| "to compare slices of the bytes sequences.") { 9020| 2.76k| janet_arity(argc, 2, 5); 9021| 2.76k| JanetByteView a = janet_getbytes(argv, 0); 9022| 2.76k| JanetByteView b = janet_getbytes(argv, 1); 9023| 2.76k| int32_t len = janet_optnat(argv, argc, 2, a.len < b.len ? a.len : b.len); ------------------ | Branch (9023:47): [True: 0, False: 2.76k] ------------------ 9024| 2.76k| int32_t offset_a = janet_optnat(argv, argc, 3, 0); 9025| 2.76k| int32_t offset_b = janet_optnat(argv, argc, 4, 0); 9026| 2.76k| if (offset_a + len > a.len) janet_panicf("invalid offset-a: %d", offset_a); ------------------ | Branch (9026:9): [True: 0, False: 2.76k] ------------------ 9027| 2.76k| if (offset_b + len > b.len) janet_panicf("invalid offset-b: %d", offset_b); ------------------ | Branch (9027:9): [True: 0, False: 2.76k] ------------------ 9028| 2.76k| return janet_wrap_integer(memcmp(a.bytes + offset_a, b.bytes + offset_b, (size_t) len)); ------------------ | | 967| 2.76k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 2.76k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 9029| 2.76k|} janet_core_env: 9667| 264|JanetTable *janet_core_env(JanetTable *replacements) { 9668| | /* Memoize core env, ignoring replacements the second time around. */ 9669| 264| if (NULL != janet_vm.core_env) { ------------------ | Branch (9669:9): [True: 0, False: 264] ------------------ 9670| 0| return janet_vm.core_env; 9671| 0| } 9672| | 9673| 264| JanetTable *dict = janet_core_lookup_table(replacements); 9674| | 9675| | /* Unmarshal bytecode */ 9676| 264| Janet marsh_out = janet_unmarshal( 9677| 264| janet_core_image, 9678| 264| janet_core_image_size, 9679| 264| 0, 9680| 264| dict, 9681| 264| NULL); 9682| | 9683| | /* Memoize */ 9684| 264| janet_gcroot(marsh_out); 9685| 264| JanetTable *env = janet_unwrap_table(marsh_out); ------------------ | | 861| 264|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9686| 264| janet_vm.core_env = env; 9687| | 9688| | /* Invert image dict manually here. We can't do this in boot.janet as it 9689| | * breaks deterministic builds */ 9690| 264| Janet lidv, midv; 9691| 264| lidv = midv = janet_wrap_nil(); ------------------ | | 831| 264|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 264| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 264|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9692| 264| janet_resolve(env, janet_csymbol("load-image-dict"), &lidv); 9693| 264| janet_resolve(env, janet_csymbol("make-image-dict"), &midv); 9694| | 9695| | /* Check that we actually got tables - if we are using a smaller corelib, may not exist */ 9696| 264| if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 528| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 264, False: 0] | | | Branch (806:6): [Folded, False: 264] | | ------------------ | | 807| 528| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 528| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 264| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 264|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 264|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(lidv, JANET_TABLE) && janet_checktype(midv, JANET_TABLE)) { ------------------ | | 806| 264| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 264, False: 0] | | | Branch (806:6): [Folded, False: 264] | | ------------------ | | 807| 264| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 264| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 264| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 264|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 264|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9697| 264| JanetTable *lid = janet_unwrap_table(lidv); ------------------ | | 861| 264|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9698| 264| JanetTable *mid = janet_unwrap_table(midv); ------------------ | | 861| 264|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 9699| 540k| for (int32_t i = 0; i < lid->capacity; i++) { ------------------ | Branch (9699:29): [True: 540k, False: 264] ------------------ 9700| 540k| const JanetKV *kv = lid->data + i; 9701| 540k| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 540k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 540k] | | ------------------ | | 807| 540k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 540k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 540k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 540k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 540k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 540k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (9701:17): [True: 173k, False: 366k] ------------------ 9702| 173k| janet_table_put(mid, kv->value, kv->key); 9703| 173k| } 9704| 540k| } 9705| 264| } 9706| | 9707| 264| return env; 9708| 264|} janet_core_lookup_table: 9712| 264|JanetTable *janet_core_lookup_table(JanetTable *replacements) { 9713| 264| JanetTable *dict = janet_table(512); 9714| 264| janet_load_libs(dict); 9715| | 9716| | /* Add replacements */ 9717| 264| if (replacements != NULL) { ------------------ | Branch (9717:9): [True: 0, False: 264] ------------------ 9718| 0| for (int32_t i = 0; i < replacements->capacity; i++) { ------------------ | Branch (9718:29): [True: 0, False: 0] ------------------ 9719| 0| JanetKV kv = replacements->data[i]; 9720| 0| if (!janet_checktype(kv.key, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (9720:17): [True: 0, False: 0] ------------------ 9721| 0| janet_table_put(dict, kv.key, kv.value); 9722| | /* Add replacement functions to registry? */ 9723| 0| } 9724| 0| } 9725| 0| } 9726| | 9727| 264| return dict; 9728| 264|} janet_lib_debug: 10180| 264|void janet_lib_debug(JanetTable *env) { 10181| 264| JanetRegExt debug_cfuns[] = { 10182| 264| JANET_CORE_REG("debug/break", cfun_debug_break), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10183| 264| JANET_CORE_REG("debug/unbreak", cfun_debug_unbreak), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10184| 264| JANET_CORE_REG("debug/fbreak", cfun_debug_fbreak), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10185| 264| JANET_CORE_REG("debug/unfbreak", cfun_debug_unfbreak), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10186| 264| JANET_CORE_REG("debug/arg-stack", cfun_debug_argstack), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10187| 264| JANET_CORE_REG("debug/stack", cfun_debug_stack), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10188| 264| JANET_CORE_REG("debug/stacktrace", cfun_debug_stacktrace), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10189| 264| JANET_CORE_REG("debug/lineage", cfun_debug_lineage), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10190| 264| JANET_CORE_REG("debug/step", cfun_debug_step), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 10191| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 10192| 264| }; 10193| | janet_core_cfuns_ext(env, NULL, debug_cfuns); 10194| 264|} janetc_allocfar: 10232| 6.10M|int32_t janetc_allocfar(JanetCompiler *c) { 10233| 6.10M| int32_t reg = janetc_regalloc_1(&c->scope->ra); 10234| 6.10M| if (reg > 0xFFFF) { ------------------ | Branch (10234:9): [True: 1.12M, False: 4.98M] ------------------ 10235| 1.12M| janetc_cerror(c, "ran out of internal registers"); 10236| 1.12M| } 10237| 6.10M| return reg; 10238| 6.10M|} janetc_allocnear: 10241| 1.10M|int32_t janetc_allocnear(JanetCompiler *c, JanetcRegisterTemp tag) { 10242| 1.10M| return janetc_regalloc_temp(&c->scope->ra, tag); 10243| 1.10M|} janetc_emit: 10246| 19.1M|void janetc_emit(JanetCompiler *c, uint32_t instr) { 10247| 19.1M| janet_v_push(c->buffer, instr); ------------------ | | 757| 19.1M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 19.1M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 19.1M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 19.0M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 19.0M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 19.0M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 19.0M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 25.3k, False: 19.0M] | | | | | | | Branch (768:50): [True: 59.9k, False: 19.0M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 85.3k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 19.1M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 19.1M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 10248| | janet_v_push(c->mapbuffer, c->current_mapping); ------------------ | | 757| 19.1M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 19.1M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 19.1M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 19.0M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 19.0M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 19.0M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 19.0M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 25.3k, False: 19.0M] | | | | | | | Branch (768:50): [True: 59.9k, False: 19.0M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 85.3k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 19.1M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 19.1M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 10249| 19.1M|} janetc_sequal: 10423| 1.29M|int janetc_sequal(JanetSlot lhs, JanetSlot rhs) { 10424| 1.29M| if ((lhs.flags & ~JANET_SLOTTYPE_ANY) == (rhs.flags & ~JANET_SLOTTYPE_ANY) && ------------------ | | 1048| 1.29M|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ if ((lhs.flags & ~JANET_SLOTTYPE_ANY) == (rhs.flags & ~JANET_SLOTTYPE_ANY) && ------------------ | | 1048| 1.29M|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ | Branch (10424:9): [True: 1.18M, False: 103k] ------------------ 10425| 1.18M| lhs.index == rhs.index && ------------------ | Branch (10425:13): [True: 2.55k, False: 1.18M] ------------------ 10426| 2.55k| lhs.envindex == rhs.envindex) { ------------------ | Branch (10426:13): [True: 2.55k, False: 0] ------------------ 10427| 2.55k| if (lhs.flags & (JANET_SLOT_REF | JANET_SLOT_CONSTANT)) { ------------------ | | 1041| 2.55k|#define JANET_SLOT_REF 0x80000 ------------------ if (lhs.flags & (JANET_SLOT_REF | JANET_SLOT_CONSTANT)) { ------------------ | | 1038| 2.55k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (10427:13): [True: 549, False: 2.00k] ------------------ 10428| 549| return janet_equals(lhs.constant, rhs.constant); 10429| 2.00k| } else { 10430| 2.00k| return 1; 10431| 2.00k| } 10432| 2.55k| } 10433| 1.28M| return 0; 10434| 1.29M|} janetc_copy: 10441| 1.29M| JanetSlot src) { 10442| 1.29M| if (dest.flags & JANET_SLOT_CONSTANT) { ------------------ | | 1038| 1.29M|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (10442:9): [True: 0, False: 1.29M] ------------------ 10443| 0| janetc_cerror(c, "cannot write to constant"); 10444| 0| return; 10445| 0| } 10446| 1.29M| if (janetc_sequal(dest, src)) return; ------------------ | Branch (10446:9): [True: 2.55k, False: 1.28M] ------------------ 10447| | /* If dest is a near register */ 10448| 1.28M| if (dest.envindex < 0 && dest.index >= 0 && dest.index <= 0xFF) { ------------------ | Branch (10448:9): [True: 1.28M, False: 626] | Branch (10448:30): [True: 1.28M, False: 549] | Branch (10448:49): [True: 156k, False: 1.13M] ------------------ 10449| 156k| janetc_movenear(c, dest.index, src); 10450| 156k| return; 10451| 156k| } 10452| | /* If src is a near register */ 10453| 1.13M| if (src.envindex < 0 && src.index >= 0 && src.index <= 0xFF) { ------------------ | Branch (10453:9): [True: 1.13M, False: 0] | Branch (10453:29): [True: 1.03M, False: 94.5k] | Branch (10453:47): [True: 22.2k, False: 1.01M] ------------------ 10454| 22.2k| janetc_moveback(c, dest, src.index); 10455| 22.2k| return; 10456| 22.2k| } 10457| | /* Process: src -> near -> dest */ 10458| 1.10M| int32_t nearreg = janetc_allocnear(c, JANETC_REGTEMP_3); 10459| 1.10M| janetc_movenear(c, nearreg, src); 10460| 1.10M| janetc_moveback(c, dest, nearreg); 10461| | /* Cleanup */ 10462| 1.10M| janetc_regalloc_freetemp(&c->scope->ra, nearreg, JANETC_REGTEMP_3); 10463| 1.10M|} janetc_emit_s: 10477| 2.07M|int32_t janetc_emit_s(JanetCompiler *c, uint8_t op, JanetSlot s, int wr) { 10478| 2.07M| int32_t reg = janetc_regfar(c, s, JANETC_REGTEMP_0); 10479| 2.07M| int32_t label = janet_v_count(c->buffer); ------------------ | | 759| 2.07M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.06M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.06M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.06M, False: 285] | | ------------------ ------------------ 10480| 2.07M| janetc_emit(c, op | ((uint32_t) reg << 8)); 10481| 2.07M| if (wr) ------------------ | Branch (10481:9): [True: 1.50M, False: 562k] ------------------ 10482| 1.50M| janetc_moveback(c, s, reg); 10483| 2.07M| janetc_free_regnear(c, s, reg, JANETC_REGTEMP_0); 10484| 2.07M| return label; 10485| 2.07M|} janetc_emit_si: 10500| 73.6k|int32_t janetc_emit_si(JanetCompiler *c, uint8_t op, JanetSlot s, int16_t immediate, int wr) { 10501| 73.6k| return emit1s(c, op, s, immediate, wr); 10502| 73.6k|} janetc_emit_su: 10504| 131k|int32_t janetc_emit_su(JanetCompiler *c, uint8_t op, JanetSlot s, uint16_t immediate, int wr) { 10505| 131k| return emit1s(c, op, s, (int32_t) immediate, wr); 10506| 131k|} janetc_emit_ss: 10520| 1.95M|int32_t janetc_emit_ss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int wr) { 10521| 1.95M| int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0); 10522| 1.95M| int32_t reg2 = janetc_regfar(c, s2, JANETC_REGTEMP_1); 10523| 1.95M| int32_t label = janet_v_count(c->buffer); ------------------ | | 759| 1.95M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.95M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.95M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.95M, False: 0] | | ------------------ ------------------ 10524| 1.95M| janetc_emit(c, op | ((uint32_t) reg1 << 8) | ((uint32_t) reg2 << 16)); 10525| 1.95M| janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1); 10526| 1.95M| if (wr) ------------------ | Branch (10526:9): [True: 334k, False: 1.62M] ------------------ 10527| 334k| janetc_moveback(c, s1, reg1); 10528| 1.95M| janetc_free_regnear(c, s1, reg1, JANETC_REGTEMP_0); 10529| 1.95M| return label; 10530| 1.95M|} janetc_emit_ssi: 10532| 928|int32_t janetc_emit_ssi(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int8_t immediate, int wr) { 10533| 928| return emit2s(c, op, s1, s2, immediate, wr); 10534| 928|} janetc_emit_ssu: 10536| 1.87M|int32_t janetc_emit_ssu(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, uint8_t immediate, int wr) { 10537| 1.87M| return emit2s(c, op, s1, s2, (int32_t) immediate, wr); 10538| 1.87M|} janetc_emit_sss: 10540| 405k|int32_t janetc_emit_sss(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, JanetSlot s3, int wr) { 10541| 405k| int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0); 10542| 405k| int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1); 10543| 405k| int32_t reg3 = janetc_regnear(c, s3, JANETC_REGTEMP_2); 10544| 405k| int32_t label = janet_v_count(c->buffer); ------------------ | | 759| 405k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 405k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 405k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 405k, False: 0] | | ------------------ ------------------ 10545| 405k| janetc_emit(c, op | ((uint32_t) reg1 << 8) | ((uint32_t) reg2 << 16) | ((uint32_t) reg3 << 24)); 10546| 405k| janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1); 10547| 405k| janetc_free_regnear(c, s3, reg3, JANETC_REGTEMP_2); 10548| 405k| if (wr) ------------------ | Branch (10548:9): [True: 158k, False: 247k] ------------------ 10549| 158k| janetc_moveback(c, s1, reg1); 10550| 405k| janetc_free_regnear(c, s1, reg1, JANETC_REGTEMP_0); 10551| 405k| return label; 10552| 405k|} janet_async_end: 10824| 68.6k|void janet_async_end(JanetFiber *fiber) { 10825| 68.6k| if (fiber->ev_callback) { ------------------ | Branch (10825:9): [True: 0, False: 68.6k] ------------------ 10826| 0| if (fiber->ev_stream->read_fiber == fiber) { ------------------ | Branch (10826:13): [True: 0, False: 0] ------------------ 10827| 0| fiber->ev_stream->read_fiber = NULL; 10828| 0| } 10829| 0| if (fiber->ev_stream->write_fiber == fiber) { ------------------ | Branch (10829:13): [True: 0, False: 0] ------------------ 10830| 0| fiber->ev_stream->write_fiber = NULL; 10831| 0| } 10832| 0| fiber->ev_callback(fiber, JANET_ASYNC_EVENT_DEINIT); 10833| 0| janet_gcunroot(janet_wrap_abstract(fiber->ev_stream)); ------------------ | | 851| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10834| 0| fiber->ev_callback = NULL; 10835| 0| if (!(fiber->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { ------------------ | | 847| 0|#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 ------------------ | Branch (10835:13): [True: 0, False: 0] ------------------ 10836| 0| if (fiber->ev_state) { ------------------ | Branch (10836:17): [True: 0, False: 0] ------------------ 10837| 0| janet_free(fiber->ev_state); ------------------ | | 2415| 0|#define janet_free(X) free((X)) ------------------ 10838| | fiber->ev_state = NULL; 10839| 0| } 10840| 0| janet_ev_dec_refcount(); 10841| 0| } 10842| 0| } 10843| 68.6k|} janet_fiber_did_resume: 10874| 68.6k|void janet_fiber_did_resume(JanetFiber *fiber) { 10875| 68.6k| janet_async_end(fiber); 10876| 68.6k|} janet_ev_init_common: 11153| 264|void janet_ev_init_common(void) { 11154| 264| janet_q_init(&janet_vm.spawn); 11155| 264| janet_vm.tq = NULL; 11156| 264| janet_vm.tq_count = 0; 11157| 264| janet_vm.tq_capacity = 0; 11158| 264| janet_table_init_raw(&janet_vm.threaded_abstracts, 0); 11159| 264| janet_table_init_raw(&janet_vm.active_tasks, 0); 11160| 264| janet_table_init_raw(&janet_vm.signal_handlers, 0); 11161| 264| janet_rng_seed(&janet_vm.ev_rng, 0); 11162| 264|#ifndef JANET_WINDOWS 11163| 264| pthread_attr_init(&janet_vm.new_thread_attr); 11164| | pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED); 11165| 264|#endif 11166| 264|} janet_ev_deinit_common: 11199| 264|void janet_ev_deinit_common(void) { 11200| 264| JanetTimeout to; 11201| 264| while (peek_timeout(&to)) { ------------------ | Branch (11201:12): [True: 0, False: 264] ------------------ 11202| 0| handle_timeout_worker(to, 1); 11203| 0| pop_timeout(0); 11204| 0| } 11205| 264| janet_q_deinit(&janet_vm.spawn); 11206| 264| janet_free(janet_vm.tq); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 11207| 264| janet_table_deinit(&janet_vm.threaded_abstracts); 11208| 264| janet_table_deinit(&janet_vm.active_tasks); 11209| 264| janet_table_deinit(&janet_vm.signal_handlers); 11210| 264|#ifndef JANET_WINDOWS 11211| 264| pthread_attr_destroy(&janet_vm.new_thread_attr); 11212| 264|#endif 11213| 264|} janet_ev_init: 12490| 264|void janet_ev_init(void) { 12491| 264| janet_ev_init_common(); 12492| 264| janet_ev_setup_selfpipe(); 12493| 264| janet_vm.epoll = epoll_create1(EPOLL_CLOEXEC); 12494| 264| janet_vm.timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); 12495| 264| janet_vm.timer_enabled = 0; 12496| 264| if (janet_vm.epoll == -1 || janet_vm.timerfd == -1) goto error; ------------------ | Branch (12496:9): [True: 0, False: 264] | Branch (12496:33): [True: 0, False: 264] ------------------ 12497| 264| struct epoll_event ev; 12498| 264| ev.events = EPOLLIN | EPOLLET; 12499| 264| ev.data.ptr = &janet_vm.timerfd; 12500| 264| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.timerfd, &ev)) goto error; ------------------ | Branch (12500:9): [True: 0, False: 264] ------------------ 12501| 264| ev.events = EPOLLIN | EPOLLET; 12502| 264| ev.data.ptr = janet_vm.selfpipe; 12503| 264| if (-1 == epoll_ctl(janet_vm.epoll, EPOLL_CTL_ADD, janet_vm.selfpipe[0], &ev)) goto error; ------------------ | Branch (12503:9): [True: 0, False: 264] ------------------ 12504| 264| return; 12505| 264|error: 12506| | JANET_EXIT("failed to initialize event loop"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 12507| 0|} janet_ev_deinit: 12509| 264|void janet_ev_deinit(void) { 12510| 264| janet_ev_deinit_common(); 12511| 264| close(janet_vm.epoll); 12512| 264| close(janet_vm.timerfd); 12513| 264| janet_ev_cleanup_selfpipe(); 12514| 264| janet_vm.epoll = 0; 12515| 264|} janet_make_pipe: 13612| 264|int janet_make_pipe(JanetHandle handles[2], int mode) { 13613| |#ifdef JANET_WINDOWS 13614| | /* 13615| | * On windows, the built in CreatePipe function doesn't support overlapped IO 13616| | * so we lift from the windows source code and modify for our own version. 13617| | */ 13618| | JanetHandle shandle, chandle; 13619| | CHAR PipeNameBuffer[MAX_PATH]; 13620| | SECURITY_ATTRIBUTES saAttr; 13621| | memset(&saAttr, 0, sizeof(saAttr)); 13622| | saAttr.nLength = sizeof(saAttr); 13623| | saAttr.bInheritHandle = TRUE; 13624| | if (mode == 3) { 13625| | /* No overlapped IO involved, just call CreatePipe */ 13626| | if (!CreatePipe(handles, handles + 1, &saAttr, 0)) return -1; 13627| | return 0; 13628| | } 13629| | snprintf(PipeNameBuffer, 13630| | sizeof(PipeNameBuffer), 13631| | "\\\\.\\Pipe\\JanetPipeFile.%08x.%08x", 13632| | (unsigned int) GetCurrentProcessId(), 13633| | (unsigned int) InterlockedIncrement(&PipeSerialNumber)); 13634| | 13635| | /* server handle goes to subprocess */ 13636| | shandle = CreateNamedPipeA( 13637| | PipeNameBuffer, 13638| | (mode == 2 ? PIPE_ACCESS_INBOUND : PIPE_ACCESS_OUTBOUND) | FILE_FLAG_OVERLAPPED, 13639| | PIPE_TYPE_BYTE | PIPE_WAIT, 13640| | 255, /* Max number of pipes for duplication. */ 13641| | 4096, /* Out buffer size */ 13642| | 4096, /* In buffer size */ 13643| | 120 * 1000, /* Timeout in ms */ 13644| | &saAttr); 13645| | if (shandle == INVALID_HANDLE_VALUE) { 13646| | return -1; 13647| | } 13648| | 13649| | /* we keep client handle */ 13650| | chandle = CreateFileA( 13651| | PipeNameBuffer, 13652| | (mode == 2 ? GENERIC_WRITE : GENERIC_READ), 13653| | 0, 13654| | &saAttr, 13655| | OPEN_EXISTING, 13656| | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 13657| | NULL); 13658| | 13659| | if (chandle == INVALID_HANDLE_VALUE) { 13660| | CloseHandle(shandle); 13661| | return -1; 13662| | } 13663| | if (mode == 2) { 13664| | handles[0] = shandle; 13665| | handles[1] = chandle; 13666| | } else { 13667| | handles[0] = chandle; 13668| | handles[1] = shandle; 13669| | } 13670| | return 0; 13671| |#else 13672| 264| if (pipe(handles)) return -1; ------------------ | Branch (13672:9): [True: 0, False: 264] ------------------ 13673| 264| if (mode != 2 && fcntl(handles[0], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (13673:9): [True: 264, False: 0] | Branch (13673:22): [True: 0, False: 264] ------------------ 13674| 264| if (mode != 1 && fcntl(handles[1], F_SETFD, FD_CLOEXEC)) goto error; ------------------ | Branch (13674:9): [True: 0, False: 264] | Branch (13674:22): [True: 0, False: 0] ------------------ 13675| 264| if (mode != 2 && mode != 3 && fcntl(handles[0], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (13675:9): [True: 264, False: 0] | Branch (13675:22): [True: 264, False: 0] | Branch (13675:35): [True: 0, False: 264] ------------------ 13676| 264| if (mode != 1 && mode != 3 && fcntl(handles[1], F_SETFL, O_NONBLOCK)) goto error; ------------------ | Branch (13676:9): [True: 0, False: 264] | Branch (13676:22): [True: 0, False: 0] | Branch (13676:35): [True: 0, False: 0] ------------------ 13677| 264| return 0; 13678| 0|error: 13679| 0| close(handles[0]); 13680| 0| close(handles[1]); 13681| 0| return -1; 13682| 264|#endif 13683| 264|} janet_lib_ev: 14268| 264|void janet_lib_ev(JanetTable *env) { 14269| 264| JanetRegExt ev_cfuns_ext[] = { 14270| 264| JANET_CORE_REG("ev/give", cfun_channel_push), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14271| 264| JANET_CORE_REG("ev/take", cfun_channel_pop), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14272| 264| JANET_CORE_REG("ev/full", cfun_channel_full), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14273| 264| JANET_CORE_REG("ev/capacity", cfun_channel_capacity), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14274| 264| JANET_CORE_REG("ev/count", cfun_channel_count), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14275| 264| JANET_CORE_REG("ev/select", cfun_channel_choice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14276| 264| JANET_CORE_REG("ev/rselect", cfun_channel_rchoice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14277| 264| JANET_CORE_REG("ev/chan", cfun_channel_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14278| 264| JANET_CORE_REG("ev/thread-chan", cfun_channel_new_threaded), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14279| 264| JANET_CORE_REG("ev/chan-close", cfun_channel_close), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14280| 264| JANET_CORE_REG("ev/go", cfun_ev_go), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14281| 264| JANET_CORE_REG("ev/thread", cfun_ev_thread), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14282| 264| JANET_CORE_REG("ev/give-supervisor", cfun_ev_give_supervisor), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14283| 264| JANET_CORE_REG("ev/sleep", cfun_ev_sleep), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14284| 264| JANET_CORE_REG("ev/deadline", cfun_ev_deadline), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14285| 264| JANET_CORE_REG("ev/cancel", cfun_ev_cancel), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14286| 264| JANET_CORE_REG("ev/close", janet_cfun_stream_close), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14287| 264| JANET_CORE_REG("ev/read", janet_cfun_stream_read), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14288| 264| JANET_CORE_REG("ev/chunk", janet_cfun_stream_chunk), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14289| 264| JANET_CORE_REG("ev/write", janet_cfun_stream_write), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14290| 264| JANET_CORE_REG("ev/lock", janet_cfun_mutex), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14291| 264| JANET_CORE_REG("ev/acquire-lock", janet_cfun_mutex_acquire), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14292| 264| JANET_CORE_REG("ev/release-lock", janet_cfun_mutex_release), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14293| 264| JANET_CORE_REG("ev/rwlock", janet_cfun_rwlock), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14294| 264| JANET_CORE_REG("ev/acquire-rlock", janet_cfun_rwlock_read_lock), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14295| 264| JANET_CORE_REG("ev/acquire-wlock", janet_cfun_rwlock_write_lock), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14296| 264| JANET_CORE_REG("ev/release-rlock", janet_cfun_rwlock_read_release), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14297| 264| JANET_CORE_REG("ev/release-wlock", janet_cfun_rwlock_write_release), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14298| 264| JANET_CORE_REG("ev/to-file", janet_cfun_to_file), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14299| 264| JANET_CORE_REG("ev/all-tasks", janet_cfun_ev_all_tasks), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 14300| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 14301| 264| }; 14302| | 14303| | janet_core_cfuns_ext(env, NULL, ev_cfuns_ext); 14304| 264| janet_register_abstract_type(&janet_stream_type); 14305| 264| janet_register_abstract_type(&janet_channel_type); 14306| 264| janet_register_abstract_type(&janet_mutex_type); 14307| 264| janet_register_abstract_type(&janet_rwlock_type); 14308| 264|} janet_lib_ffi: 16241| 264|void janet_lib_ffi(JanetTable *env) { 16242| 264| JanetRegExt ffi_cfuns[] = { 16243| 264| JANET_CORE_REG("ffi/native", janet_core_raw_native), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16244| 264| JANET_CORE_REG("ffi/lookup", janet_core_native_lookup), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16245| 264| JANET_CORE_REG("ffi/close", janet_core_native_close), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16246| 264| JANET_CORE_REG("ffi/signature", cfun_ffi_signature), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16247| 264| JANET_CORE_REG("ffi/call", cfun_ffi_call), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16248| 264| JANET_CORE_REG("ffi/struct", cfun_ffi_struct), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16249| 264| JANET_CORE_REG("ffi/write", cfun_ffi_buffer_write), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16250| 264| JANET_CORE_REG("ffi/read", cfun_ffi_buffer_read), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16251| 264| JANET_CORE_REG("ffi/size", cfun_ffi_size), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16252| 264| JANET_CORE_REG("ffi/align", cfun_ffi_align), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16253| 264| JANET_CORE_REG("ffi/trampoline", cfun_ffi_get_callback_trampoline), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16254| 264| JANET_CORE_REG("ffi/jitfn", cfun_ffi_jitfn), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16255| 264| JANET_CORE_REG("ffi/malloc", cfun_ffi_malloc), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16256| 264| JANET_CORE_REG("ffi/free", cfun_ffi_free), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16257| 264| JANET_CORE_REG("ffi/pointer-buffer", cfun_ffi_pointer_buffer), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16258| 264| JANET_CORE_REG("ffi/pointer-cfunction", cfun_ffi_pointer_cfunction), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16259| 264| JANET_CORE_REG("ffi/calling-conventions", cfun_ffi_supported_calling_conventions), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16260| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16261| 264| }; 16262| | janet_core_cfuns_ext(env, NULL, ffi_cfuns); 16263| 264|} janet_fiber_reset: 16338| 68.6k|JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv) { 16339| 68.6k| int32_t newstacktop; 16340| 68.6k| fiber_reset(fiber); 16341| 68.6k| if (argc) { ------------------ | Branch (16341:9): [True: 68.6k, False: 2] ------------------ 16342| 68.6k| newstacktop = fiber->stacktop + argc; 16343| 68.6k| if (newstacktop >= fiber->capacity) { ------------------ | Branch (16343:13): [True: 33, False: 68.6k] ------------------ 16344| 33| janet_fiber_setcapacity(fiber, 2 * newstacktop); 16345| 33| } 16346| 68.6k| if (argv) { ------------------ | Branch (16346:13): [True: 68.6k, False: 0] ------------------ 16347| 68.6k| memcpy(fiber->data + fiber->stacktop, argv, argc * sizeof(Janet)); 16348| 68.6k| } else { 16349| | /* If argv not given, fill with nil */ 16350| 0| for (int32_t i = 0; i < argc; i++) { ------------------ | Branch (16350:33): [True: 0, False: 0] ------------------ 16351| 0| fiber->data[fiber->stacktop + i] = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16352| 0| } 16353| 0| } 16354| 68.6k| fiber->stacktop = newstacktop; 16355| 68.6k| } 16356| | /* Don't panic on failure since we use this to implement janet_pcall */ 16357| 68.6k| if (janet_fiber_funcframe(fiber, callee)) return NULL; ------------------ | Branch (16357:9): [True: 4, False: 68.6k] ------------------ 16358| 68.6k| janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE; ------------------ | | 855| 68.6k|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 68.6k|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 68.6k|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE; ------------------ | | 1013| 68.6k|#define JANET_STACKFRAME_ENTRANCE 2 ------------------ 16359| 68.6k|#ifdef JANET_EV 16360| | fiber->supervisor_channel = NULL; 16361| 68.6k|#endif 16362| 68.6k| return fiber; 16363| 68.6k|} janet_fiber: 16366| 68.6k|JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv) { 16367| 68.6k| return janet_fiber_reset(fiber_alloc(capacity), callee, argc, argv); 16368| 68.6k|} janet_fiber_setcapacity: 16387| 125k|void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) { 16388| 125k| int32_t old_size = fiber->capacity; 16389| 125k| int32_t diff = n - old_size; 16390| 125k| Janet *newData = janet_realloc(fiber->data, sizeof(Janet) * n); ------------------ | | 2409| 125k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 16391| 125k| if (NULL == newData) { ------------------ | Branch (16391:9): [True: 0, False: 125k] ------------------ 16392| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16393| 0| } 16394| 125k| fiber->data = newData; 16395| 125k| fiber->capacity = n; 16396| 125k| janet_vm.next_collection += sizeof(Janet) * diff; 16397| 125k|} janet_fiber_push: 16406| 32.1M|void janet_fiber_push(JanetFiber *fiber, Janet x) { 16407| 32.1M| if (fiber->stacktop == INT32_MAX) janet_panic("stack overflow"); ------------------ | Branch (16407:9): [True: 0, False: 32.1M] ------------------ 16408| 32.1M| if (fiber->stacktop >= fiber->capacity) { ------------------ | Branch (16408:9): [True: 1.18k, False: 32.1M] ------------------ 16409| 1.18k| janet_fiber_grow(fiber, fiber->stacktop); 16410| 1.18k| } 16411| 32.1M| fiber->data[fiber->stacktop++] = x; 16412| 32.1M|} janet_fiber_push2: 16415| 14.4M|void janet_fiber_push2(JanetFiber *fiber, Janet x, Janet y) { 16416| 14.4M| if (fiber->stacktop >= INT32_MAX - 1) janet_panic("stack overflow"); ------------------ | Branch (16416:9): [True: 0, False: 14.4M] ------------------ 16417| 14.4M| int32_t newtop = fiber->stacktop + 2; 16418| 14.4M| if (newtop > fiber->capacity) { ------------------ | Branch (16418:9): [True: 1, False: 14.4M] ------------------ 16419| 1| janet_fiber_grow(fiber, newtop); 16420| 1| } 16421| 14.4M| fiber->data[fiber->stacktop] = x; 16422| 14.4M| fiber->data[fiber->stacktop + 1] = y; 16423| 14.4M| fiber->stacktop = newtop; 16424| 14.4M|} janet_fiber_push3: 16427| 12.8M|void janet_fiber_push3(JanetFiber *fiber, Janet x, Janet y, Janet z) { 16428| 12.8M| if (fiber->stacktop >= INT32_MAX - 2) janet_panic("stack overflow"); ------------------ | Branch (16428:9): [True: 0, False: 12.8M] ------------------ 16429| 12.8M| int32_t newtop = fiber->stacktop + 3; 16430| 12.8M| if (newtop > fiber->capacity) { ------------------ | Branch (16430:9): [True: 4.46k, False: 12.8M] ------------------ 16431| 4.46k| janet_fiber_grow(fiber, newtop); 16432| 4.46k| } 16433| 12.8M| fiber->data[fiber->stacktop] = x; 16434| 12.8M| fiber->data[fiber->stacktop + 1] = y; 16435| 12.8M| fiber->data[fiber->stacktop + 2] = z; 16436| 12.8M| fiber->stacktop = newtop; 16437| 12.8M|} janet_fiber_pushn: 16440| 2.27M|void janet_fiber_pushn(JanetFiber *fiber, const Janet *arr, int32_t n) { 16441| 2.27M| if (fiber->stacktop > INT32_MAX - n) janet_panic("stack overflow"); ------------------ | Branch (16441:9): [True: 0, False: 2.27M] ------------------ 16442| 2.27M| int32_t newtop = fiber->stacktop + n; 16443| 2.27M| if (newtop > fiber->capacity) { ------------------ | Branch (16443:9): [True: 30, False: 2.27M] ------------------ 16444| 30| janet_fiber_grow(fiber, newtop); 16445| 30| } 16446| 2.27M| safe_memcpy(fiber->data + fiber->stacktop, arr, n * sizeof(Janet)); 16447| 2.27M| fiber->stacktop = newtop; 16448| 2.27M|} janet_fiber_funcframe: 16462| 11.1M|int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) { 16463| 11.1M| JanetStackFrame *newframe; 16464| | 16465| 11.1M| int32_t i; 16466| 11.1M| int32_t oldtop = fiber->stacktop; 16467| 11.1M| int32_t oldframe = fiber->frame; 16468| 11.1M| int32_t nextframe = fiber->stackstart; 16469| 11.1M| int32_t nextstacktop = nextframe + func->def->slotcount + JANET_FRAME_SIZE; ------------------ | | 1026| 11.1M|#define JANET_FRAME_SIZE 4 ------------------ 16470| 11.1M| int32_t next_arity = fiber->stacktop - fiber->stackstart; 16471| | 16472| | /* Check strict arity before messing with state */ 16473| 11.1M| if (next_arity < func->def->min_arity) return 1; ------------------ | Branch (16473:9): [True: 0, False: 11.1M] ------------------ 16474| 11.1M| if (next_arity > func->def->max_arity) return 1; ------------------ | Branch (16474:9): [True: 4, False: 11.1M] ------------------ 16475| | 16476| 11.1M| if (fiber->capacity < nextstacktop) { ------------------ | Branch (16476:9): [True: 119k, False: 11.0M] ------------------ 16477| 119k| janet_fiber_setcapacity(fiber, 2 * nextstacktop); 16478| |#ifdef JANET_DEBUG 16479| | } else { 16480| | janet_fiber_refresh_memory(fiber); 16481| |#endif 16482| 119k| } 16483| | 16484| | /* Nil unset stack arguments (Needed for gc correctness) */ 16485| 175M| for (i = fiber->stacktop; i < nextstacktop; ++i) { ------------------ | Branch (16485:31): [True: 164M, False: 11.1M] ------------------ 16486| 164M| fiber->data[i] = janet_wrap_nil(); ------------------ | | 831| 164M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 164M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 164M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 164M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16487| 164M| } 16488| | 16489| | /* Set up the next frame */ 16490| 11.1M| fiber->frame = nextframe; 16491| 11.1M| fiber->stacktop = fiber->stackstart = nextstacktop; 16492| 11.1M| newframe = janet_fiber_frame(fiber); ------------------ | | 855| 11.1M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 11.1M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 11.1M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16493| 11.1M| newframe->prevframe = oldframe; 16494| 11.1M| newframe->pc = func->def->bytecode; 16495| 11.1M| newframe->func = func; 16496| 11.1M| newframe->env = NULL; 16497| 11.1M| newframe->flags = 0; 16498| | 16499| | /* Check varargs */ 16500| 11.1M| if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) { ------------------ | | 1097| 11.1M|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ | Branch (16500:9): [True: 1.05M, False: 10.1M] ------------------ 16501| 1.05M| int32_t tuplehead = fiber->frame + func->def->arity; 16502| 1.05M| janet_assert(tuplehead > 0, "fiber stack overflow"); ------------------ | | 389| 1.05M|#define janet_assert(c, m) do { \ | | 390| 1.05M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 1.05M] | | ------------------ | | 391| 1.05M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 1.05M] | | ------------------ ------------------ 16503| 1.05M| int st = func->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG; ------------------ | | 1105| 1.05M|#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 ------------------ 16504| 1.05M| if (tuplehead >= oldtop) { ------------------ | Branch (16504:13): [True: 1.05M, False: 5.18k] ------------------ 16505| 1.05M| fiber->data[tuplehead] = st ------------------ | Branch (16505:38): [True: 0, False: 1.05M] ------------------ 16506| 1.05M| ? make_struct_n(NULL, 0) 16507| 1.05M| : janet_wrap_tuple(janet_tuple_n(NULL, 0)); ------------------ | | 843| 1.05M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 2.10M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.05M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.05M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16508| 1.05M| } else { 16509| 5.18k| fiber->data[tuplehead] = st ------------------ | Branch (16509:38): [True: 0, False: 5.18k] ------------------ 16510| 5.18k| ? make_struct_n( 16511| 0| fiber->data + tuplehead, 16512| 0| oldtop - tuplehead) 16513| 5.18k| : janet_wrap_tuple(janet_tuple_n( ------------------ | | 843| 5.18k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 10.3k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 5.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16514| 5.18k| fiber->data + tuplehead, 16515| 5.18k| oldtop - tuplehead)); 16516| 5.18k| } 16517| 1.05M| } 16518| | 16519| | /* Good return */ 16520| 11.1M| return 0; 16521| 11.1M|} janet_env_valid: 16556| 6.05M|int janet_env_valid(JanetFuncEnv *env) { 16557| 6.05M| if (env->offset < 0) { ------------------ | Branch (16557:9): [True: 0, False: 6.05M] ------------------ 16558| 0| int32_t real_offset = -(env->offset); 16559| 0| JanetFiber *fiber = env->as.fiber; 16560| 0| int32_t i = fiber->frame; 16561| 0| while (i > 0) { ------------------ | Branch (16561:16): [True: 0, False: 0] ------------------ 16562| 0| JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE); ------------------ | | 1026| 0|#define JANET_FRAME_SIZE 4 ------------------ 16563| 0| if (real_offset == i && ------------------ | Branch (16563:17): [True: 0, False: 0] ------------------ 16564| 0| frame->env == env && ------------------ | Branch (16564:21): [True: 0, False: 0] ------------------ 16565| 0| frame->func && ------------------ | Branch (16565:21): [True: 0, False: 0] ------------------ 16566| 0| frame->func->def->slotcount == env->length) { ------------------ | Branch (16566:21): [True: 0, False: 0] ------------------ 16567| 0| env->offset = real_offset; 16568| 0| return 1; 16569| 0| } 16570| 0| i = frame->prevframe; 16571| 0| } 16572| | /* Invalid, set to empty off-stack variant. */ 16573| 0| env->offset = 0; 16574| 0| env->length = 0; 16575| 0| env->as.values = NULL; 16576| 0| return 0; 16577| 6.05M| } else { 16578| 6.05M| return 1; 16579| 6.05M| } 16580| 6.05M|} janet_fiber_funcframe_tail: 16602| 3.83M|int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) { 16603| 3.83M| int32_t i; 16604| 3.83M| int32_t nextframetop = fiber->frame + func->def->slotcount; 16605| 3.83M| int32_t nextstacktop = nextframetop + JANET_FRAME_SIZE; ------------------ | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 ------------------ 16606| 3.83M| int32_t next_arity = fiber->stacktop - fiber->stackstart; 16607| 3.83M| int32_t stacksize; 16608| | 16609| | /* Check strict arity before messing with state */ 16610| 3.83M| if (next_arity < func->def->min_arity) return 1; ------------------ | Branch (16610:9): [True: 1, False: 3.83M] ------------------ 16611| 3.83M| if (next_arity > func->def->max_arity) return 1; ------------------ | Branch (16611:9): [True: 228, False: 3.83M] ------------------ 16612| | 16613| 3.83M| if (fiber->capacity < nextstacktop) { ------------------ | Branch (16613:9): [True: 68, False: 3.83M] ------------------ 16614| 68| janet_fiber_setcapacity(fiber, 2 * nextstacktop); 16615| |#ifdef JANET_DEBUG 16616| | } else { 16617| | janet_fiber_refresh_memory(fiber); 16618| |#endif 16619| 68| } 16620| | 16621| | /* Detach old function */ 16622| 3.83M| if (NULL != janet_fiber_frame(fiber)->func) ------------------ | | 855| 3.83M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 3.83M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ | Branch (16622:9): [True: 3.83M, False: 0] ------------------ 16623| 3.83M| janet_env_detach(janet_fiber_frame(fiber)->env); ------------------ | | 855| 3.83M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 3.83M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16624| 3.83M| janet_fiber_frame(fiber)->env = NULL; ------------------ | | 855| 3.83M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 3.83M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16625| | 16626| | /* Check varargs */ 16627| 3.83M| if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) { ------------------ | | 1097| 3.83M|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ | Branch (16627:9): [True: 8.47k, False: 3.82M] ------------------ 16628| 8.47k| int32_t tuplehead = fiber->stackstart + func->def->arity; 16629| 8.47k| int st = func->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG; ------------------ | | 1105| 8.47k|#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 ------------------ 16630| 8.47k| if (tuplehead >= fiber->stacktop) { ------------------ | Branch (16630:13): [True: 12, False: 8.46k] ------------------ 16631| 12| if (tuplehead >= fiber->capacity) janet_fiber_setcapacity(fiber, 2 * (tuplehead + 1)); ------------------ | Branch (16631:17): [True: 0, False: 12] ------------------ 16632| 12| for (i = fiber->stacktop; i < tuplehead; ++i) fiber->data[i] = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (16632:39): [True: 0, False: 12] ------------------ 16633| 12| fiber->data[tuplehead] = st ------------------ | Branch (16633:38): [True: 0, False: 12] ------------------ 16634| 12| ? make_struct_n(NULL, 0) 16635| 12| : janet_wrap_tuple(janet_tuple_n(NULL, 0)); ------------------ | | 843| 12|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 24| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 12|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 12|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16636| 8.46k| } else { 16637| 8.46k| fiber->data[tuplehead] = st ------------------ | Branch (16637:38): [True: 0, False: 8.46k] ------------------ 16638| 8.46k| ? make_struct_n( 16639| 0| fiber->data + tuplehead, 16640| 0| fiber->stacktop - tuplehead) 16641| 8.46k| : janet_wrap_tuple(janet_tuple_n( ------------------ | | 843| 8.46k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 16.9k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 8.46k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.46k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16642| 8.46k| fiber->data + tuplehead, 16643| 8.46k| fiber->stacktop - tuplehead)); 16644| 8.46k| } 16645| 8.47k| stacksize = tuplehead - fiber->stackstart + 1; 16646| 3.82M| } else { 16647| 3.82M| stacksize = fiber->stacktop - fiber->stackstart; 16648| 3.82M| } 16649| | 16650| 3.83M| if (stacksize) memmove(fiber->data + fiber->frame, fiber->data + fiber->stackstart, stacksize * sizeof(Janet)); ------------------ | Branch (16650:9): [True: 3.83M, False: 292] ------------------ 16651| | 16652| | /* Nil unset locals (Needed for functional correctness) */ 16653| 61.8M| for (i = fiber->frame + stacksize; i < nextframetop; ++i) ------------------ | Branch (16653:40): [True: 57.9M, False: 3.83M] ------------------ 16654| 57.9M| fiber->data[i] = janet_wrap_nil(); ------------------ | | 831| 57.9M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 61.8M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 57.9M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 57.9M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16655| | 16656| | /* Set stack stuff */ 16657| 3.83M| fiber->stacktop = fiber->stackstart = nextstacktop; 16658| | 16659| | /* Set frame stuff */ 16660| 3.83M| janet_fiber_frame(fiber)->func = func; ------------------ | | 855| 3.83M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 3.83M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16661| 3.83M| janet_fiber_frame(fiber)->pc = func->def->bytecode; ------------------ | | 855| 3.83M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 3.83M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16662| 3.83M| janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_TAILCALL; ------------------ | | 855| 3.83M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 3.83M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 3.83M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_TAILCALL; ------------------ | | 1010| 3.83M|#define JANET_STACKFRAME_TAILCALL 1 ------------------ 16663| | 16664| | /* Good return */ 16665| 3.83M| return 0; 16666| 3.83M|} janet_fiber_cframe: 16669| 28.4M|void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun) { 16670| 28.4M| JanetStackFrame *newframe; 16671| | 16672| 28.4M| int32_t oldframe = fiber->frame; 16673| 28.4M| int32_t nextframe = fiber->stackstart; 16674| 28.4M| int32_t nextstacktop = fiber->stacktop + JANET_FRAME_SIZE; ------------------ | | 1026| 28.4M|#define JANET_FRAME_SIZE 4 ------------------ 16675| | 16676| 28.4M| if (fiber->capacity < nextstacktop) { ------------------ | Branch (16676:9): [True: 588, False: 28.4M] ------------------ 16677| 588| janet_fiber_setcapacity(fiber, 2 * nextstacktop); 16678| |#ifdef JANET_DEBUG 16679| | } else { 16680| | janet_fiber_refresh_memory(fiber); 16681| |#endif 16682| 588| } 16683| | 16684| | /* Set the next frame */ 16685| 28.4M| fiber->frame = nextframe; 16686| 28.4M| fiber->stacktop = fiber->stackstart = nextstacktop; 16687| 28.4M| newframe = janet_fiber_frame(fiber); ------------------ | | 855| 28.4M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 28.4M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 28.4M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16688| | 16689| | /* Set up the new frame */ 16690| 28.4M| newframe->prevframe = oldframe; 16691| 28.4M| newframe->pc = (uint32_t *) cfun; 16692| 28.4M| newframe->func = NULL; 16693| | newframe->env = NULL; 16694| 28.4M| newframe->flags = 0; 16695| 28.4M|} janet_fiber_popframe: 16698| 38.9M|void janet_fiber_popframe(JanetFiber *fiber) { 16699| 38.9M| JanetStackFrame *frame = janet_fiber_frame(fiber); ------------------ | | 855| 38.9M|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 38.9M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 38.9M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ 16700| 38.9M| if (fiber->frame == 0) return; ------------------ | Branch (16700:9): [True: 0, False: 38.9M] ------------------ 16701| | 16702| | /* Clean up the frame (detach environments) */ 16703| 38.9M| if (NULL != frame->func) ------------------ | Branch (16703:9): [True: 10.5M, False: 28.4M] ------------------ 16704| 10.5M| janet_env_detach(frame->env); 16705| | 16706| | /* Shrink stack */ 16707| 38.9M| fiber->stacktop = fiber->stackstart = fiber->frame; 16708| 38.9M| fiber->frame = frame->prevframe; 16709| 38.9M|} janet_fiber_status: 16711| 137k|JanetFiberStatus janet_fiber_status(JanetFiber *f) { 16712| 137k| return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 830| 137k|#define JANET_FIBER_STATUS_MASK 0x3F0000 ------------------ return ((f)->flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 832| 137k|#define JANET_FIBER_STATUS_OFFSET 16 ------------------ 16713| 137k|} janet_lib_fiber: 16943| 264|void janet_lib_fiber(JanetTable *env) { 16944| 264| JanetRegExt fiber_cfuns[] = { 16945| 264| JANET_CORE_REG("fiber/new", cfun_fiber_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16946| 264| JANET_CORE_REG("fiber/status", cfun_fiber_status), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16947| 264| JANET_CORE_REG("fiber/root", cfun_fiber_root), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16948| 264| JANET_CORE_REG("fiber/current", cfun_fiber_current), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16949| 264| JANET_CORE_REG("fiber/maxstack", cfun_fiber_maxstack), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16950| 264| JANET_CORE_REG("fiber/setmaxstack", cfun_fiber_setmaxstack), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16951| 264| JANET_CORE_REG("fiber/getenv", cfun_fiber_getenv), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16952| 264| JANET_CORE_REG("fiber/setenv", cfun_fiber_setenv), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16953| 264| JANET_CORE_REG("fiber/can-resume?", cfun_fiber_can_resume), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16954| 264| JANET_CORE_REG("fiber/last-value", cfun_fiber_last_value), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 16955| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 16956| 264| }; 16957| | janet_core_cfuns_ext(env, NULL, fiber_cfuns); 16958| 264|} janet_lib_filewatch: 17953| 264|void janet_lib_filewatch(JanetTable *env) { 17954| 264| JanetRegExt cfuns[] = { 17955| 264| JANET_CORE_REG("filewatch/new", cfun_filewatch_make), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17956| 264| JANET_CORE_REG("filewatch/add", cfun_filewatch_add), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17957| 264| JANET_CORE_REG("filewatch/remove", cfun_filewatch_remove), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17958| 264| JANET_CORE_REG("filewatch/listen", cfun_filewatch_listen), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17959| 264| JANET_CORE_REG("filewatch/unlisten", cfun_filewatch_unlisten), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 17960| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 17961| 264| }; 17962| | janet_core_cfuns_ext(env, NULL, cfuns); 17963| 264|} janet_gcpressure: 18023| 118k|void janet_gcpressure(size_t s) { 18024| 118k| janet_vm.next_collection += s; 18025| 118k|} janet_gcalloc: 18497| 34.9M|void *janet_gcalloc(enum JanetMemoryType type, size_t size) { 18498| 34.9M| JanetGCObject *mem; 18499| | 18500| | /* Make sure everything is inited */ 18501| 34.9M| janet_assert(NULL != janet_vm.cache, "please initialize janet before use"); ------------------ | | 389| 34.9M|#define janet_assert(c, m) do { \ | | 390| 34.9M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 34.9M] | | ------------------ | | 391| 34.9M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 34.9M] | | ------------------ ------------------ 18502| 34.9M| mem = janet_malloc(size); ------------------ | | 2406| 34.9M|#define janet_malloc(X) malloc((X)) ------------------ 18503| | 18504| | /* Check for bad malloc */ 18505| 34.9M| if (NULL == mem) { ------------------ | Branch (18505:9): [True: 0, False: 34.9M] ------------------ 18506| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18507| 0| } 18508| | 18509| | /* Configure block */ 18510| 34.9M| mem->flags = type; 18511| | 18512| | /* Prepend block to heap list */ 18513| 34.9M| janet_vm.next_collection += size; 18514| 34.9M| if (type < JANET_MEMORY_TABLE_WEAKK) { ------------------ | Branch (18514:9): [True: 34.9M, False: 0] ------------------ 18515| | /* normal heap */ 18516| 34.9M| mem->data.next = janet_vm.blocks; 18517| 34.9M| janet_vm.blocks = mem; 18518| 34.9M| } else { 18519| | /* weak heap */ 18520| 0| mem->data.next = janet_vm.weak_blocks; 18521| 0| janet_vm.weak_blocks = mem; 18522| 0| } 18523| 34.9M| janet_vm.block_count++; 18524| | 18525| 34.9M| return (void *)mem; 18526| 34.9M|} janet_collect: 18549| 121M|void janet_collect(void) { 18550| 121M| uint32_t i; 18551| 121M| if (janet_vm.gc_suspend) return; ------------------ | Branch (18551:9): [True: 121M, False: 0] ------------------ 18552| 0| depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ 18553| 0| janet_vm.gc_mark_phase = 1; 18554| | /* Try to prevent many major collections back to back. 18555| | * A full collection will take O(janet_vm.block_count) time. 18556| | * If we have a large heap, make sure our interval is not too 18557| | * small so we won't make many collections over it. This is just a 18558| | * heuristic for automatically changing the gc interval */ 18559| 0| if (janet_vm.block_count * 8 > janet_vm.gc_interval) { ------------------ | Branch (18559:9): [True: 0, False: 0] ------------------ 18560| 0| janet_vm.gc_interval = janet_vm.block_count * sizeof(JanetGCObject); 18561| 0| } 18562| 0| orig_rootcount = janet_vm.root_count; 18563| 0|#ifdef JANET_EV 18564| 0| janet_ev_mark(); 18565| 0|#endif 18566| 0| if (janet_vm.top_dyns) { ------------------ | Branch (18566:9): [True: 0, False: 0] ------------------ 18567| 0| janet_mark(janet_wrap_table(janet_vm.top_dyns)); ------------------ | | 846| 0|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18568| 0| } 18569| 0| if (janet_vm.root_fiber != NULL) { /* Can be NULL if janet_collect called outside of interpreter loop */ ------------------ | Branch (18569:9): [True: 0, False: 0] ------------------ 18570| 0| janet_mark_fiber(janet_vm.root_fiber); 18571| 0| } 18572| 0| for (i = 0; i < orig_rootcount; i++) ------------------ | Branch (18572:17): [True: 0, False: 0] ------------------ 18573| 0| janet_mark(janet_vm.roots[i]); 18574| 0| while (orig_rootcount < janet_vm.root_count) { ------------------ | Branch (18574:12): [True: 0, False: 0] ------------------ 18575| 0| Janet x = janet_vm.roots[--janet_vm.root_count]; 18576| 0| janet_mark(x); 18577| 0| } 18578| 0| janet_vm.gc_mark_phase = 0; 18579| 0| janet_sweep(); 18580| 0| janet_vm.next_collection = 0; 18581| 0| janet_free_all_scratch(); 18582| 0|} janet_gcroot: 18587| 528|void janet_gcroot(Janet root) { 18588| 528| size_t newcount = janet_vm.root_count + 1; 18589| 528| if (newcount > janet_vm.root_capacity) { ------------------ | Branch (18589:9): [True: 264, False: 264] ------------------ 18590| 264| size_t newcap = 2 * newcount; 18591| 264| janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap); ------------------ | | 2409| 264|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18592| 264| if (NULL == janet_vm.roots) { ------------------ | Branch (18592:13): [True: 0, False: 264] ------------------ 18593| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18594| 0| } 18595| 264| janet_vm.root_capacity = newcap; 18596| 264| } 18597| 528| janet_vm.roots[janet_vm.root_count] = root; 18598| 528| janet_vm.root_count = newcount; 18599| 528|} janet_clear_memory: 18645| 264|void janet_clear_memory(void) { 18646| 264|#ifdef JANET_EV 18647| 264| JanetKV *items = janet_vm.threaded_abstracts.data; 18648| 528| for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) { ------------------ | Branch (18648:25): [True: 264, False: 264] ------------------ 18649| 264| if (janet_checktype(items[i].key, JANET_ABSTRACT)) { ------------------ | | 806| 264| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 264] | | | Branch (806:6): [Folded, False: 264] | | ------------------ | | 807| 264| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 264| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 264| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 264|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 264|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18650| 0| void *abst = janet_unwrap_abstract(items[i].key); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 18651| 0| JanetAbstractHead *head = janet_abstract_head(abst); ------------------ | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) ------------------ 18652| 0| if (head->type->gcperthread) { ------------------ | Branch (18652:17): [True: 0, False: 0] ------------------ 18653| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 18654| 0| } 18655| 0| janet_abstract_decref_maybe_free(abst); 18656| 0| } 18657| 264| } 18658| 264|#endif 18659| 264| JanetGCObject *current = janet_vm.blocks; 18660| 34.9M| while (NULL != current) { ------------------ | Branch (18660:12): [True: 34.9M, False: 264] ------------------ 18661| 34.9M| janet_deinit_block(current); 18662| 34.9M| JanetGCObject *next = current->data.next; 18663| 34.9M| janet_free(current); ------------------ | | 2415| 34.9M|#define janet_free(X) free((X)) ------------------ 18664| 34.9M| current = next; 18665| 34.9M| } 18666| 264| janet_vm.blocks = NULL; 18667| 264| janet_free_all_scratch(); 18668| 264| janet_free(janet_vm.scratch_mem); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 18669| 264|} janet_gclock: 18672| 68.6k|int janet_gclock(void) { 18673| 68.6k| return janet_vm.gc_suspend++; 18674| 68.6k|} janet_gcunlock: 18675| 68.6k|void janet_gcunlock(int handle) { 18676| 68.6k| janet_vm.gc_suspend = handle; 18677| 68.6k|} janet_smalloc: 18683| 2.54M|void *janet_smalloc(size_t size) { 18684| 2.54M| JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size); ------------------ | | 2406| 2.54M|#define janet_malloc(X) malloc((X)) ------------------ 18685| 2.54M| if (NULL == s) { ------------------ | Branch (18685:9): [True: 0, False: 2.54M] ------------------ 18686| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18687| 0| } 18688| 2.54M| s->finalize = NULL; 18689| 2.54M| if (janet_vm.scratch_len == janet_vm.scratch_cap) { ------------------ | Branch (18689:9): [True: 805, False: 2.54M] ------------------ 18690| 805| size_t newcap = 2 * janet_vm.scratch_cap + 2; 18691| 805| JanetScratch **newmem = (JanetScratch **) janet_realloc(janet_vm.scratch_mem, newcap * sizeof(JanetScratch)); ------------------ | | 2409| 805|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18692| 805| if (NULL == newmem) { ------------------ | Branch (18692:13): [True: 0, False: 805] ------------------ 18693| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18694| 0| } 18695| 805| janet_vm.scratch_cap = newcap; 18696| 805| janet_vm.scratch_mem = newmem; 18697| 805| } 18698| 2.54M| janet_vm.scratch_mem[janet_vm.scratch_len++] = s; 18699| 2.54M| return (char *)(s->mem); 18700| 2.54M|} janet_srealloc: 18712| 4.36M|void *janet_srealloc(void *mem, size_t size) { 18713| 4.36M| if (NULL == mem) return janet_smalloc(size); ------------------ | Branch (18713:9): [True: 2.32M, False: 2.04M] ------------------ 18714| 2.04M| JanetScratch *s = janet_mem2scratch(mem); 18715| 2.04M| if (janet_vm.scratch_len) { ------------------ | Branch (18715:9): [True: 2.04M, False: 0] ------------------ 18716| 2.21M| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 18717| 2.21M| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (18717:17): [True: 2.04M, False: 168k] ------------------ 18718| 2.04M| JanetScratch *news = janet_realloc(s, size + sizeof(JanetScratch)); ------------------ | | 2409| 2.04M|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 18719| 2.04M| if (NULL == news) { ------------------ | Branch (18719:21): [True: 0, False: 2.04M] ------------------ 18720| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 18721| 0| } 18722| 2.04M| janet_vm.scratch_mem[i] = news; 18723| 2.04M| return (char *)(news->mem); 18724| 2.04M| } 18725| 168k| if (i == 0) break; ------------------ | Branch (18725:17): [True: 0, False: 168k] ------------------ 18726| 168k| } 18727| 2.04M| } 18728| 0| JANET_EXIT("invalid janet_srealloc"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 18729| 0|} janet_sfree: 18736| 2.54M|void janet_sfree(void *mem) { 18737| 2.54M| if (NULL == mem) return; ------------------ | Branch (18737:9): [True: 0, False: 2.54M] ------------------ 18738| 2.54M| JanetScratch *s = janet_mem2scratch(mem); 18739| 2.54M| if (janet_vm.scratch_len) { ------------------ | Branch (18739:9): [True: 2.54M, False: 0] ------------------ 18740| 2.87M| for (size_t i = janet_vm.scratch_len - 1; ; i--) { 18741| 2.87M| if (janet_vm.scratch_mem[i] == s) { ------------------ | Branch (18741:17): [True: 2.54M, False: 332k] ------------------ 18742| 2.54M| janet_vm.scratch_mem[i] = janet_vm.scratch_mem[--janet_vm.scratch_len]; 18743| 2.54M| free_one_scratch(s); 18744| 2.54M| return; 18745| 2.54M| } 18746| 332k| if (i == 0) break; ------------------ | Branch (18746:17): [True: 0, False: 332k] ------------------ 18747| 332k| } 18748| 2.54M| } 18749| 0| JANET_EXIT("invalid janet_sfree"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 18750| 0|} janet_unwrap_u64: 18899| 2|uint64_t janet_unwrap_u64(Janet x) { 18900| 2| switch (janet_type(x)) { ------------------ | | 795| 2| (isnan((x).number) \ | | 796| 2| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 2| : JANET_NUMBER) ------------------ | Branch (18900:13): [True: 2, False: 0] ------------------ 18901| 0| default: ------------------ | Branch (18901:9): [True: 0, False: 2] ------------------ 18902| 0| break; 18903| 0| case JANET_NUMBER : { ------------------ | Branch (18903:9): [True: 0, False: 2] ------------------ 18904| 0| double d = janet_unwrap_number(x); ------------------ | | 839| 0|#define janet_unwrap_number(x) ((x).number) ------------------ 18905| 0| if (!janet_checkuint64range(d)) break; ------------------ | | 965| 0|#define janet_checkuint64range(x) ((x) >= 0 && (x) <= JANET_INTMAX_DOUBLE && (x) == (uint64_t)(x)) | | ------------------ | | | | 165| 0|#define JANET_INTMAX_DOUBLE 9007199254740992.0 | | ------------------ | | | Branch (965:36): [True: 0, False: 0] | | | Branch (965:48): [True: 0, False: 0] | | | Branch (965:78): [True: 0, False: 0] | | ------------------ ------------------ 18906| 0| return (uint64_t) d; 18907| 0| } 18908| 0| case JANET_STRING: { ------------------ | Branch (18908:9): [True: 0, False: 2] ------------------ 18909| 0| uint64_t value; 18910| 0| const uint8_t *str = janet_unwrap_string(x); ------------------ | | 863| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 18911| 0| if (janet_scan_uint64(str, janet_string_length(str), &value)) ------------------ | | 1813| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (18911:17): [True: 0, False: 0] ------------------ 18912| 0| return value; 18913| 0| break; 18914| 0| } 18915| 2| case JANET_ABSTRACT: { ------------------ | Branch (18915:9): [True: 2, False: 0] ------------------ 18916| 2| void *abst = janet_unwrap_abstract(x); ------------------ | | 866| 2|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 18917| 2| if (janet_abstract_type(abst) == &janet_s64_type || ------------------ | | 1899| 2|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 2|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ | Branch (18917:17): [True: 0, False: 2] ------------------ 18918| 2| (janet_abstract_type(abst) == &janet_u64_type)) ------------------ | | 1899| 2|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 2|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ | Branch (18918:21): [True: 2, False: 0] ------------------ 18919| 2| return *(uint64_t *)abst; 18920| 0| break; 18921| 2| } 18922| 2| } 18923| 0| janet_panicf("can not convert %t %q to a 64 bit unsigned integer", x, x); 18924| 0| return 0; 18925| 2|} janet_wrap_s64: 18935| 5.76k|Janet janet_wrap_s64(int64_t x) { 18936| 5.76k| int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t)); 18937| 5.76k| *box = (int64_t)x; 18938| 5.76k| return janet_wrap_abstract(box); ------------------ | | 851| 5.76k|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 5.76k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 5.76k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.76k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18939| 5.76k|} janet_wrap_u64: 18941| 356|Janet janet_wrap_u64(uint64_t x) { 18942| 356| uint64_t *box = janet_abstract(&janet_u64_type, sizeof(uint64_t)); 18943| 356| *box = (uint64_t)x; 18944| 356| return janet_wrap_abstract(box); ------------------ | | 851| 356|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 356| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 356|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 356|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18945| 356|} janet_lib_inttypes: 19427| 264|void janet_lib_inttypes(JanetTable *env) { 19428| 264| JanetRegExt it_cfuns[] = { 19429| 264| JANET_CORE_REG("int/s64", cfun_it_s64_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19430| 264| JANET_CORE_REG("int/u64", cfun_it_u64_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19431| 264| JANET_CORE_REG("int/to-number", cfun_to_number), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19432| 264| JANET_CORE_REG("int/to-bytes", cfun_to_bytes), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 19433| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 19434| 264| }; 19435| | janet_core_cfuns_ext(env, NULL, it_cfuns); 19436| 264| janet_register_abstract_type(&janet_s64_type); 19437| 264| janet_register_abstract_type(&janet_u64_type); 19438| 264|} janet_file_close: 19754| 792|int janet_file_close(JanetFile *file) { 19755| 792| int ret = 0; 19756| 792| if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2278| 792|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { ------------------ | | 2279| 792|#define JANET_FILE_CLOSED 32 ------------------ | Branch (19756:9): [True: 0, False: 792] ------------------ 19757| 0| ret = fclose(file->file); 19758| 0| file->flags |= JANET_FILE_CLOSED; ------------------ | | 2279| 0|#define JANET_FILE_CLOSED 32 ------------------ 19759| 0| file->file = NULL; /* NULL dereference is easier to debug then other problems */ 19760| 0| return ret; 19761| 0| } 19762| 792| return 0; 19763| 792|} janet_makefile: 20262| 792|Janet janet_makefile(FILE *f, int32_t flags) { 20263| 792| return janet_wrap_abstract(makef(f, flags, BUFSIZ)); ------------------ | | 851| 792|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 792| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 792|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 792|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 20264| 792|} janet_lib_io: 20277| 264|void janet_lib_io(JanetTable *env) { 20278| 264| JanetRegExt io_cfuns[] = { 20279| 264| JANET_CORE_REG("print", cfun_io_print), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20280| 264| JANET_CORE_REG("prin", cfun_io_prin), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20281| 264| JANET_CORE_REG("printf", cfun_io_printf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20282| 264| JANET_CORE_REG("prinf", cfun_io_prinf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20283| 264| JANET_CORE_REG("eprin", cfun_io_eprin), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20284| 264| JANET_CORE_REG("eprint", cfun_io_eprint), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20285| 264| JANET_CORE_REG("eprintf", cfun_io_eprintf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20286| 264| JANET_CORE_REG("eprinf", cfun_io_eprinf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20287| 264| JANET_CORE_REG("xprint", cfun_io_xprint), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20288| 264| JANET_CORE_REG("xprin", cfun_io_xprin), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20289| 264| JANET_CORE_REG("xprintf", cfun_io_xprintf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20290| 264| JANET_CORE_REG("xprinf", cfun_io_xprinf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20291| 264| JANET_CORE_REG("flush", cfun_io_flush), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20292| 264| JANET_CORE_REG("eflush", cfun_io_eflush), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20293| 264| JANET_CORE_REG("file/temp", cfun_io_temp), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20294| 264| JANET_CORE_REG("file/open", cfun_io_fopen), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20295| 264| JANET_CORE_REG("file/close", cfun_io_fclose), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20296| 264| JANET_CORE_REG("file/read", cfun_io_fread), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20297| 264| JANET_CORE_REG("file/write", cfun_io_fwrite), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20298| 264| JANET_CORE_REG("file/flush", cfun_io_fflush), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20299| 264| JANET_CORE_REG("file/seek", cfun_io_fseek), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20300| 264| JANET_CORE_REG("file/tell", cfun_io_ftell), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 20301| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 20302| 264| }; 20303| 264| janet_core_cfuns_ext(env, NULL, io_cfuns); 20304| 264| janet_register_abstract_type(&janet_file_type); 20305| 264| int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2278| 264|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ int default_flags = JANET_FILE_NOT_CLOSEABLE | JANET_FILE_SERIALIZABLE; ------------------ | | 2281| 264|#define JANET_FILE_SERIALIZABLE 128 ------------------ 20306| | /* stdout */ 20307| 264| JANET_CORE_DEF(env, "stdout", ------------------ | | 520| 264|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20308| 264| janet_makefile(stdout, JANET_FILE_APPEND | default_flags), 20309| 264| "The standard output file."); 20310| | /* stderr */ 20311| 264| JANET_CORE_DEF(env, "stderr", ------------------ | | 520| 264|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20312| 264| janet_makefile(stderr, JANET_FILE_APPEND | default_flags), 20313| 264| "The standard error file."); 20314| | /* stdin */ 20315| 264| JANET_CORE_DEF(env, "stdin", ------------------ | | 520| 264|#define JANET_CORE_DEF(ENV, NAME, X, DOC) janet_core_def_sm(ENV, NAME, X, DOC, NULL, 0) ------------------ 20316| 264| janet_makefile(stdin, JANET_FILE_READ | default_flags), 20317| 264| "The standard input file."); 20318| | 20319| 264|} janet_unmarshal: 21978| 264| const uint8_t **next) { 21979| 264| UnmarshalState st; 21980| 264| st.start = bytes; 21981| 264| st.end = bytes + len; 21982| 264| st.lookup_defs = NULL; 21983| 264| st.lookup_envs = NULL; 21984| 264| st.lookup = NULL; 21985| 264| st.reg = reg; 21986| 264| Janet out; 21987| 264| const uint8_t *nextbytes = unmarshal_one(&st, bytes, &out, flags); 21988| 264| if (next) *next = nextbytes; ------------------ | Branch (21988:9): [True: 0, False: 264] ------------------ 21989| 264| janet_v_free(st.lookup_defs); ------------------ | | 756| 264|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 264|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 264, False: 0] | | ------------------ ------------------ 21990| 264| janet_v_free(st.lookup_envs); ------------------ | | 756| 264|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 264|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 264, False: 0] | | ------------------ ------------------ 21991| | janet_v_free(st.lookup); ------------------ | | 756| 264|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 264|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 264, False: 0] | | ------------------ ------------------ 21992| 264| return out; 21993| 264|} janet_lib_marsh: 22054| 264|void janet_lib_marsh(JanetTable *env) { 22055| 264| JanetRegExt marsh_cfuns[] = { 22056| 264| JANET_CORE_REG("marshal", cfun_marshal), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22057| 264| JANET_CORE_REG("unmarshal", cfun_unmarshal), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22058| 264| JANET_CORE_REG("env-lookup", cfun_env_lookup), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22059| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22060| 264| }; 22061| | janet_core_cfuns_ext(env, NULL, marsh_cfuns); 22062| 264|} janet_default_rng: 22137| 264|JanetRNG *janet_default_rng(void) { 22138| 264| return &janet_vm.rng; 22139| 264|} janet_rng_seed: 22141| 528|void janet_rng_seed(JanetRNG *rng, uint32_t seed) { 22142| 528| rng->a = seed; 22143| 528| rng->b = 0x97654321u; 22144| 528| rng->c = 123871873u; 22145| 528| rng->d = 0xf23f56c8u; 22146| 528| rng->counter = 0u; 22147| | /* First several numbers aren't that random. */ 22148| 8.97k| for (int i = 0; i < 16; i++) janet_rng_u32(rng); ------------------ | Branch (22148:21): [True: 8.44k, False: 528] ------------------ 22149| 528|} janet_rng_u32: 22165| 8.44k|uint32_t janet_rng_u32(JanetRNG *rng) { 22166| | /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */ 22167| 8.44k| uint32_t t = rng->d; 22168| 8.44k| uint32_t const s = rng->a; 22169| 8.44k| rng->d = rng->c; 22170| 8.44k| rng->c = rng->b; 22171| 8.44k| rng->b = s; 22172| 8.44k| t ^= t >> 2; 22173| 8.44k| t ^= t << 1; 22174| 8.44k| t ^= s ^ (s << 4); 22175| 8.44k| rng->a = t; 22176| 8.44k| rng->counter += 362437; 22177| 8.44k| return t + rng->counter; 22178| 8.44k|} janet_not: 22382| 1.51k|JANET_CORE_FN(janet_not, "(not x)", "Returns the boolean inverse of x.") { 22383| 1.51k| janet_fixarity(argc, 1); 22384| 1.51k| return janet_wrap_boolean(!janet_truthy(argv[0])); ------------------ | | 834| 1.51k|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 11.2k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.51k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.51k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [Folded, False: 1.51k] | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [Folded, False: 1.34k] | | | | | Branch (822:51): [True: 0, False: 1.34k] | | | | | Branch (822:51): [True: 1.34k, False: 3] | | | | | Branch (822:51): [True: 1.34k, False: 164] | | | | ------------------ | | ------------------ ------------------ 22385| 1.51k|} janet_lib_math: 22445| 264|void janet_lib_math(JanetTable *env) { 22446| 264| JanetRegExt math_cfuns[] = { 22447| 264| JANET_CORE_REG("not", janet_not), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22448| 264| JANET_CORE_REG("math/random", janet_rand), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22449| 264| JANET_CORE_REG("math/seedrandom", janet_srand), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22450| 264| JANET_CORE_REG("math/cos", janet_cos), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22451| 264| JANET_CORE_REG("math/sin", janet_sin), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22452| 264| JANET_CORE_REG("math/tan", janet_tan), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22453| 264| JANET_CORE_REG("math/acos", janet_acos), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22454| 264| JANET_CORE_REG("math/asin", janet_asin), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22455| 264| JANET_CORE_REG("math/atan", janet_atan), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22456| 264| JANET_CORE_REG("math/exp", janet_exp), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22457| 264| JANET_CORE_REG("math/log", janet_log), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22458| 264| JANET_CORE_REG("math/log10", janet_log10), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22459| 264| JANET_CORE_REG("math/log2", janet_log2), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22460| 264| JANET_CORE_REG("math/sqrt", janet_sqrt), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22461| 264|#ifndef JANET_PLAN9 22462| 264| JANET_CORE_REG("math/cbrt", janet_cbrt), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22463| 264| JANET_CORE_REG("math/gamma", janet_tgamma), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22464| 264| JANET_CORE_REG("math/log-gamma", janet_lgamma), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22465| 264| JANET_CORE_REG("math/erfc", janet_erfc), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22466| 264| JANET_CORE_REG("math/erf", janet_erf), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22467| 264| JANET_CORE_REG("math/expm1", janet_expm1), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22468| 264| JANET_CORE_REG("math/atanh", janet_atanh), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22469| 264| JANET_CORE_REG("math/asinh", janet_asinh), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22470| 264| JANET_CORE_REG("math/next", janet_nextafter), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22471| 264|#endif 22472| 264| JANET_CORE_REG("math/floor", janet_floor), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22473| 264| JANET_CORE_REG("math/ceil", janet_ceil), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22474| 264| JANET_CORE_REG("math/pow", janet_pow), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22475| 264| JANET_CORE_REG("math/abs", janet_fabs), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22476| 264| JANET_CORE_REG("math/sinh", janet_sinh), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22477| 264| JANET_CORE_REG("math/cosh", janet_cosh), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22478| 264| JANET_CORE_REG("math/tanh", janet_tanh), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22479| 264| JANET_CORE_REG("math/acosh", janet_acosh), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22480| 264| JANET_CORE_REG("math/atan2", janet_atan2), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22481| 264| JANET_CORE_REG("math/rng", cfun_rng_make), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22482| 264| JANET_CORE_REG("math/rng-uniform", cfun_rng_uniform), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22483| 264| JANET_CORE_REG("math/rng-int", cfun_rng_int), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22484| 264| JANET_CORE_REG("math/rng-buffer", cfun_rng_buffer), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22485| 264| JANET_CORE_REG("math/hypot", janet_hypot), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22486| 264| JANET_CORE_REG("math/exp2", janet_exp2), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22487| 264| JANET_CORE_REG("math/log1p", janet_log1p), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22488| 264| JANET_CORE_REG("math/trunc", janet_trunc), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22489| 264| JANET_CORE_REG("math/round", janet_round), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22490| 264| JANET_CORE_REG("math/gcd", janet_cfun_gcd), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22491| 264| JANET_CORE_REG("math/lcm", janet_cfun_lcm), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22492| 264| JANET_CORE_REG("math/frexp", janet_cfun_frexp), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22493| 264| JANET_CORE_REG("math/ldexp", janet_cfun_ldexp), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 22494| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 22495| 264| }; 22496| 264| janet_core_cfuns_ext(env, NULL, math_cfuns); 22497| 264| janet_register_abstract_type(&janet_rng_type); 22498| |#ifdef JANET_BOOTSTRAP 22499| | JANET_CORE_DEF(env, "math/pi", janet_wrap_number(3.1415926535897931), 22500| | "The value pi."); 22501| | JANET_CORE_DEF(env, "math/e", janet_wrap_number(2.7182818284590451), 22502| | "The base of the natural log."); 22503| | JANET_CORE_DEF(env, "math/inf", janet_wrap_number(INFINITY), 22504| | "The number representing positive infinity"); 22505| | JANET_CORE_DEF(env, "math/-inf", janet_wrap_number(-INFINITY), 22506| | "The number representing negative infinity"); 22507| | JANET_CORE_DEF(env, "math/int32-min", janet_wrap_number(INT32_MIN), 22508| | "The minimum contiguous integer representable by a 32 bit signed integer"); 22509| | JANET_CORE_DEF(env, "math/int32-max", janet_wrap_number(INT32_MAX), 22510| | "The maximum contiguous integer representable by a 32 bit signed integer"); 22511| | JANET_CORE_DEF(env, "math/int-min", janet_wrap_number(JANET_INTMIN_DOUBLE), 22512| | "The minimum contiguous integer representable by a double (-(2^53))"); 22513| | JANET_CORE_DEF(env, "math/int-max", janet_wrap_number(JANET_INTMAX_DOUBLE), 22514| | "The maximum contiguous integer representable by a double (2^53)"); 22515| |#ifdef NAN 22516| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(NAN), "Not a number (IEEE-754 NaN)"); 22517| |#else 22518| | JANET_CORE_DEF(env, "math/nan", janet_wrap_number(0.0 / 0.0), "Not a number (IEEE-754 NaN)"); 22519| |#endif 22520| |#endif 22521| 264|} janet_lib_net: 23792| 264|void janet_lib_net(JanetTable *env) { 23793| 264| JanetRegExt net_cfuns[] = { 23794| 264| JANET_CORE_REG("net/address", cfun_net_sockaddr), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23795| 264| JANET_CORE_REG("net/listen", cfun_net_listen), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23796| 264| JANET_CORE_REG("net/socket", cfun_net_socket), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23797| 264| JANET_CORE_REG("net/accept", cfun_stream_accept), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23798| 264| JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23799| 264| JANET_CORE_REG("net/read", cfun_stream_read), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23800| 264| JANET_CORE_REG("net/chunk", cfun_stream_chunk), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23801| 264| JANET_CORE_REG("net/write", cfun_stream_write), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23802| 264| JANET_CORE_REG("net/send-to", cfun_stream_send_to), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23803| 264| JANET_CORE_REG("net/recv-from", cfun_stream_recv_from), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23804| 264| JANET_CORE_REG("net/flush", cfun_stream_flush), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23805| 264| JANET_CORE_REG("net/connect", cfun_net_connect), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23806| 264| JANET_CORE_REG("net/shutdown", cfun_net_shutdown), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23807| 264| JANET_CORE_REG("net/peername", cfun_net_getpeername), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23808| 264| JANET_CORE_REG("net/localname", cfun_net_getsockname), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23809| 264| JANET_CORE_REG("net/address-unpack", cfun_net_address_unpack), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23810| 264| JANET_CORE_REG("net/setsockopt", cfun_net_setsockopt), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 23811| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 23812| 264| }; 23813| | janet_core_cfuns_ext(env, NULL, net_cfuns); 23814| 264|} janet_net_init: 23816| 264|void janet_net_init(void) { 23817| |#ifdef JANET_WINDOWS 23818| | WSADATA wsaData; 23819| | janet_assert(!WSAStartup(MAKEWORD(2, 2), &wsaData), "could not start winsock"); 23820| | janet_vm.connect_ex_loaded = 0; 23821| | janet_vm.connect_ex = NULL; 23822| |#endif 23823| 264|} janet_net_deinit: 23825| 264|void janet_net_deinit(void) { 23826| |#ifdef JANET_WINDOWS 23827| | WSACleanup(); 23828| |#endif 23829| 264|} janet_lib_os: 26841| 264|void janet_lib_os(JanetTable *env) { 26842| |#if !defined(JANET_REDUCED_OS) && defined(JANET_WINDOWS) && defined(JANET_THREADS) 26843| | /* During start up, the top-most abstract machine (thread) 26844| | * in the thread tree sets up the critical section. */ 26845| | static volatile long env_lock_initializing = 0; 26846| | static volatile long env_lock_initialized = 0; 26847| | if (!InterlockedExchange(&env_lock_initializing, 1)) { 26848| | InitializeCriticalSection(&env_lock); 26849| | InterlockedOr(&env_lock_initialized, 1); 26850| | } else { 26851| | while (!InterlockedOr(&env_lock_initialized, 0)) { 26852| | Sleep(0); 26853| | } 26854| | } 26855| | 26856| |#endif 26857| 264|#ifndef JANET_NO_PROCESSES 26858| 264|#endif 26859| 264| JanetRegExt os_cfuns[] = { 26860| 264| JANET_CORE_REG("os/exit", os_exit), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26861| 264| JANET_CORE_REG("os/which", os_which), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26862| 264| JANET_CORE_REG("os/arch", os_arch), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26863| 264| JANET_CORE_REG("os/compiler", os_compiler), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26864| 264|#ifndef JANET_REDUCED_OS 26865| | 26866| | /* misc (un-sandboxed) */ 26867| 264| JANET_CORE_REG("os/cpu-count", os_cpu_count), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26868| 264| JANET_CORE_REG("os/cwd", os_cwd), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26869| 264| JANET_CORE_REG("os/cryptorand", os_cryptorand), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26870| 264| JANET_CORE_REG("os/perm-string", os_permission_string), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26871| 264| JANET_CORE_REG("os/perm-int", os_permission_int), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26872| 264| JANET_CORE_REG("os/mktime", os_mktime), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26873| 264| JANET_CORE_REG("os/time", os_time), /* not high resolution */ ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26874| 264| JANET_CORE_REG("os/date", os_date), /* not high resolution */ ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26875| 264| JANET_CORE_REG("os/strftime", os_strftime), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26876| 264| JANET_CORE_REG("os/sleep", os_sleep), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26877| 264| JANET_CORE_REG("os/isatty", os_isatty), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26878| 264|#ifndef JANET_NO_LOCALES 26879| 264| JANET_CORE_REG("os/setlocale", os_setlocale), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26880| 264|#endif 26881| | 26882| | /* env functions */ 26883| 264|#ifndef JANET_PLAN9 26884| 264| JANET_CORE_REG("os/environ", os_environ), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26885| 264|#endif 26886| 264| JANET_CORE_REG("os/getenv", os_getenv), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26887| 264| JANET_CORE_REG("os/setenv", os_setenv), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26888| | 26889| | /* fs read */ 26890| 264| JANET_CORE_REG("os/dir", os_dir), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26891| 264| JANET_CORE_REG("os/stat", os_stat), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26892| 264| JANET_CORE_REG("os/lstat", os_lstat), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26893| 264| JANET_CORE_REG("os/realpath", os_realpath), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26894| 264| JANET_CORE_REG("os/cd", os_cd), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26895| 264|#ifndef JANET_NO_UMASK 26896| 264| JANET_CORE_REG("os/umask", os_umask), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26897| 264|#endif 26898| 264|#ifndef JANET_NO_SYMLINKS 26899| 264| JANET_CORE_REG("os/readlink", os_readlink), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26900| 264|#endif 26901| | 26902| | /* fs write */ 26903| 264| JANET_CORE_REG("os/mkdir", os_mkdir), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26904| 264| JANET_CORE_REG("os/rmdir", os_rmdir), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26905| 264| JANET_CORE_REG("os/rm", os_remove), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26906| 264| JANET_CORE_REG("os/link", os_link), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26907| 264| JANET_CORE_REG("os/rename", os_rename), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26908| 264| JANET_CORE_REG("os/chmod", os_chmod), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26909| 264| JANET_CORE_REG("os/touch", os_touch), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26910| 264|#ifndef JANET_NO_SYMLINKS 26911| 264| JANET_CORE_REG("os/symlink", os_symlink), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26912| 264|#endif 26913| | 26914| | /* processes */ 26915| 264|#ifndef JANET_NO_PROCESSES 26916| 264| JANET_CORE_REG("os/execute", os_execute), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26917| 264| JANET_CORE_REG("os/spawn", os_spawn), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26918| 264| JANET_CORE_REG("os/shell", os_shell), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26919| 264| JANET_CORE_REG("os/posix-fork", os_posix_fork), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26920| 264| JANET_CORE_REG("os/posix-exec", os_posix_exec), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26921| 264| JANET_CORE_REG("os/posix-chroot", os_posix_chroot), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26922| | /* no need to sandbox process management if you can't create processes 26923| | * (allows for limited functionality if use exposes C-functions to create specific processes) */ 26924| 264| JANET_CORE_REG("os/proc-wait", os_proc_wait), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26925| 264| JANET_CORE_REG("os/proc-kill", os_proc_kill), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26926| 264| JANET_CORE_REG("os/proc-close", os_proc_close), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26927| 264| JANET_CORE_REG("os/getpid", os_proc_getpid), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26928| 264|#ifdef JANET_EV 26929| 264| JANET_CORE_REG("os/sigaction", os_sigaction), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26930| 264|#endif 26931| 264|#endif 26932| | 26933| | /* high resolution timers */ 26934| 264| JANET_CORE_REG("os/clock", os_clock), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26935| | 26936| 264|#ifdef JANET_EV 26937| 264| JANET_CORE_REG("os/open", os_open), /* fs read and write */ ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26938| 264| JANET_CORE_REG("os/pipe", os_pipe), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 26939| 264|#endif 26940| 264|#endif 26941| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 26942| 264| }; 26943| | janet_core_cfuns_ext(env, NULL, os_cfuns); 26944| 264|} janet_is_symbol_char: 27004| 16.1M|int janet_is_symbol_char(uint8_t c) { 27005| 16.1M| return symchars[c >> 5] & ((uint32_t)1 << (c & 0x1F)); 27006| 16.1M|} janet_valid_utf8: 27011| 571k|int janet_valid_utf8(const uint8_t *str, int32_t len) { 27012| 571k| int32_t i = 0; 27013| 571k| int32_t j; 27014| 5.91M| while (i < len) { ------------------ | Branch (27014:12): [True: 5.34M, False: 570k] ------------------ 27015| 5.34M| int32_t nexti; 27016| 5.34M| uint8_t c = str[i]; 27017| | 27018| | /* Check the number of bytes in code point */ 27019| 5.34M| if (c < 0x80) nexti = i + 1; ------------------ | Branch (27019:13): [True: 5.34M, False: 3.90k] ------------------ 27020| 3.90k| else if ((c >> 5) == 0x06) nexti = i + 2; ------------------ | Branch (27020:18): [True: 1.84k, False: 2.05k] ------------------ 27021| 2.05k| else if ((c >> 4) == 0x0E) nexti = i + 3; ------------------ | Branch (27021:18): [True: 407, False: 1.65k] ------------------ 27022| 1.65k| else if ((c >> 3) == 0x1E) nexti = i + 4; ------------------ | Branch (27022:18): [True: 1.61k, False: 38] ------------------ 27023| | /* Don't allow 5 or 6 byte code points */ 27024| 38| else return 0; 27025| | 27026| | /* No overflow */ 27027| 5.34M| if (nexti > len) return 0; ------------------ | Branch (27027:13): [True: 19, False: 5.34M] ------------------ 27028| | 27029| | /* Ensure trailing bytes are well formed (10XX XXXX) */ 27030| 5.35M| for (j = i + 1; j < nexti; j++) { ------------------ | Branch (27030:25): [True: 7.46k, False: 5.34M] ------------------ 27031| 7.46k| if ((str[j] >> 6) != 2) return 0; ------------------ | Branch (27031:17): [True: 4, False: 7.46k] ------------------ 27032| 7.46k| } 27033| | 27034| | /* Check for overlong encoding */ 27035| 5.34M| if ((nexti == i + 2) && str[i] < 0xC2) return 0; ------------------ | Branch (27035:13): [True: 1.82k, False: 5.34M] | Branch (27035:33): [True: 0, False: 1.82k] ------------------ 27036| 5.34M| if ((str[i] == 0xE0) && str[i + 1] < 0xA0) return 0; ------------------ | Branch (27036:13): [True: 198, False: 5.34M] | Branch (27036:33): [True: 0, False: 198] ------------------ 27037| 5.34M| if ((str[i] == 0xF0) && str[i + 1] < 0x90) return 0; ------------------ | Branch (27037:13): [True: 406, False: 5.34M] | Branch (27037:33): [True: 0, False: 406] ------------------ 27038| | 27039| 5.34M| i = nexti; 27040| 5.34M| } 27041| 570k| return 1; 27042| 571k|} janet_parser_consume: 27646| 23.5M|void janet_parser_consume(JanetParser *parser, uint8_t c) { 27647| 23.5M| int consumed = 0; 27648| 23.5M| janet_parser_checkdead(parser); 27649| 23.5M| if (c == '\r') { ------------------ | Branch (27649:9): [True: 292k, False: 23.2M] ------------------ 27650| 292k| parser->line++; 27651| 292k| parser->column = 0; 27652| 23.2M| } else if (c == '\n') { ------------------ | Branch (27652:16): [True: 119k, False: 23.1M] ------------------ 27653| 119k| parser->column = 0; 27654| 119k| if (parser->lookback != '\r') ------------------ | Branch (27654:13): [True: 118k, False: 1.06k] ------------------ 27655| 118k| parser->line++; 27656| 23.1M| } else { 27657| 23.1M| parser->column++; 27658| 23.1M| } 27659| 52.6M| while (!consumed && !parser->error) { ------------------ | Branch (27659:12): [True: 29.0M, False: 23.5M] | Branch (27659:25): [True: 29.0M, False: 72] ------------------ 27660| 29.0M| JanetParseState *state = parser->states + parser->statecount - 1; 27661| 29.0M| consumed = state->consumer(parser, state, c); 27662| 29.0M| } 27663| 23.5M| parser->lookback = c; 27664| 23.5M|} janet_parser_status: 27679| 23.5M|enum JanetParserStatus janet_parser_status(JanetParser *parser) { 27680| 23.5M| if (parser->error) return JANET_PARSE_ERROR; ------------------ | Branch (27680:9): [True: 172, False: 23.5M] ------------------ 27681| 23.5M| if (parser->flag) return JANET_PARSE_DEAD; ------------------ | Branch (27681:9): [True: 0, False: 23.5M] ------------------ 27682| 23.5M| if (parser->statecount > 1) return JANET_PARSE_PENDING; ------------------ | Branch (27682:9): [True: 23.5M, False: 58.0k] ------------------ 27683| 58.0k| return JANET_PARSE_ROOT; 27684| 23.5M|} janet_parser_produce: 27705| 57.2k|Janet janet_parser_produce(JanetParser *parser) { 27706| 57.2k| Janet ret; 27707| 57.2k| size_t i; 27708| 57.2k| if (parser->pending == 0) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (27708:9): [True: 0, False: 57.2k] ------------------ 27709| 57.2k| ret = janet_unwrap_tuple(parser->args[0])[0]; ------------------ | | 858| 57.2k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 27710| 57.2k| for (i = 1; i < parser->argcount; i++) { ------------------ | Branch (27710:17): [True: 0, False: 57.2k] ------------------ 27711| 0| parser->args[i - 1] = parser->args[i]; 27712| 0| } 27713| 57.2k| parser->pending--; 27714| 57.2k| parser->argcount--; 27715| 57.2k| parser->states[0].argn--; 27716| 57.2k| return ret; 27717| 57.2k|} janet_parser_init: 27733| 264|void janet_parser_init(JanetParser *parser) { 27734| 264| parser->args = NULL; 27735| 264| parser->states = NULL; 27736| 264| parser->buf = NULL; 27737| 264| parser->argcount = 0; 27738| 264| parser->argcap = 0; 27739| 264| parser->bufcount = 0; 27740| 264| parser->bufcap = 0; 27741| 264| parser->statecount = 0; 27742| 264| parser->statecap = 0; 27743| 264| parser->error = NULL; 27744| 264| parser->lookback = -1; 27745| 264| parser->line = 1; 27746| 264| parser->column = 0; 27747| 264| parser->pending = 0; 27748| 264| parser->flag = 0; 27749| | 27750| 264| pushstate(parser, root, PFLAG_CONTAINER); ------------------ | |27083| 264|#define PFLAG_CONTAINER 0x100 ------------------ 27751| 264|} janet_parser_deinit: 27753| 264|void janet_parser_deinit(JanetParser *parser) { 27754| 264| janet_free(parser->args); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 27755| 264| janet_free(parser->buf); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 27756| 264| janet_free(parser->states); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 27757| 264|} janet_parser_has_more: 27804| 23.6M|int janet_parser_has_more(JanetParser *parser) { 27805| 23.6M| return !!parser->pending; 27806| 23.6M|} janet_lib_parse: 28258| 264|void janet_lib_parse(JanetTable *env) { 28259| 264| JanetRegExt parse_cfuns[] = { 28260| 264| JANET_CORE_REG("parser/new", cfun_parse_parser), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28261| 264| JANET_CORE_REG("parser/clone", cfun_parse_clone), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28262| 264| JANET_CORE_REG("parser/has-more", cfun_parse_has_more), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28263| 264| JANET_CORE_REG("parser/produce", cfun_parse_produce), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28264| 264| JANET_CORE_REG("parser/consume", cfun_parse_consume), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28265| 264| JANET_CORE_REG("parser/byte", cfun_parse_byte), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28266| 264| JANET_CORE_REG("parser/error", cfun_parse_error), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28267| 264| JANET_CORE_REG("parser/status", cfun_parse_status), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28268| 264| JANET_CORE_REG("parser/flush", cfun_parse_flush), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28269| 264| JANET_CORE_REG("parser/state", cfun_parse_state), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28270| 264| JANET_CORE_REG("parser/where", cfun_parse_where), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28271| 264| JANET_CORE_REG("parser/eof", cfun_parse_eof), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28272| 264| JANET_CORE_REG("parser/insert", cfun_parse_insert), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 28273| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 28274| 264| }; 28275| | janet_core_cfuns_ext(env, NULL, parse_cfuns); 28276| 264|} janet_lib_peg: 30383| 264|void janet_lib_peg(JanetTable *env) { 30384| 264| JanetRegExt cfuns[] = { 30385| 264| JANET_CORE_REG("peg/compile", cfun_peg_compile), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30386| 264| JANET_CORE_REG("peg/match", cfun_peg_match), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30387| 264| JANET_CORE_REG("peg/find", cfun_peg_find), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30388| 264| JANET_CORE_REG("peg/find-all", cfun_peg_find_all), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30389| 264| JANET_CORE_REG("peg/replace", cfun_peg_replace), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30390| 264| JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 30391| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 30392| 264| }; 30393| | janet_core_cfuns_ext(env, NULL, cfuns); 30394| 264| janet_register_abstract_type(&janet_peg_type); 30395| 264|} janet_to_string_b: 30625| 700k|void janet_to_string_b(JanetBuffer *buffer, Janet x) { 30626| 700k| switch (janet_type(x)) { ------------------ | | 795| 700k| (isnan((x).number) \ | | 796| 700k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 700k| : JANET_NUMBER) ------------------ | Branch (30626:13): [True: 680k, False: 19.9k] ------------------ 30627| 0| case JANET_NIL: ------------------ | Branch (30627:9): [True: 0, False: 700k] ------------------ 30628| 0| janet_buffer_push_cstring(buffer, ""); 30629| 0| break; 30630| 28| case JANET_BOOLEAN: ------------------ | Branch (30630:9): [True: 28, False: 700k] ------------------ 30631| 28| janet_buffer_push_cstring(buffer, 30632| 28| janet_unwrap_boolean(x) ? "true" : "false"); ------------------ | | 838| 28|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) | | ------------------ | | | Branch (838:33): [True: 16, False: 12] | | ------------------ ------------------ 30633| 28| break; 30634| 19.9k| case JANET_NUMBER: ------------------ | Branch (30634:9): [True: 19.9k, False: 680k] ------------------ 30635| 19.9k| number_to_string_b(buffer, janet_unwrap_number(x)); ------------------ | | 839| 19.9k|#define janet_unwrap_number(x) ((x).number) ------------------ 30636| 19.9k| break; 30637| 2.81k| case JANET_STRING: ------------------ | Branch (30637:9): [True: 2.81k, False: 698k] ------------------ 30638| 679k| case JANET_SYMBOL: ------------------ | Branch (30638:9): [True: 677k, False: 23.7k] ------------------ 30639| 680k| case JANET_KEYWORD: ------------------ | Branch (30639:9): [True: 559, False: 700k] ------------------ 30640| 680k| janet_buffer_push_bytes(buffer, 30641| 680k| janet_unwrap_string(x), ------------------ | | 863| 680k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 30642| 680k| janet_string_length(janet_unwrap_string(x))); ------------------ | | 1813| 680k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 680k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30643| 680k| break; 30644| 29| case JANET_BUFFER: { ------------------ | Branch (30644:9): [True: 29, False: 700k] ------------------ 30645| 29| JanetBuffer *to = janet_unwrap_buffer(x); ------------------ | | 862| 29|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 30646| | /* Prevent resizing buffer while appending */ 30647| 29| if (buffer == to) janet_buffer_extra(buffer, to->count); ------------------ | Branch (30647:17): [True: 0, False: 29] ------------------ 30648| 29| janet_buffer_push_bytes(buffer, to->data, to->count); 30649| 29| break; 30650| 679k| } 30651| 0| case JANET_ABSTRACT: { ------------------ | Branch (30651:9): [True: 0, False: 700k] ------------------ 30652| 0| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30653| 0| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 30654| 0| if (t->tostring != NULL) { ------------------ | Branch (30654:17): [True: 0, False: 0] ------------------ 30655| 0| t->tostring(p, buffer); 30656| 0| } else { 30657| 0| string_description_b(buffer, t->name, p); 30658| 0| } 30659| 0| } 30660| 0| return; 30661| 0| case JANET_CFUNCTION: { ------------------ | Branch (30661:9): [True: 0, False: 700k] ------------------ 30662| 0| JanetCFunRegistry *reg = janet_registry_get(janet_unwrap_cfunction(x)); ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 30663| 0| if (NULL != reg) { ------------------ | Branch (30663:17): [True: 0, False: 0] ------------------ 30664| 0| janet_buffer_push_cstring(buffer, "name_prefix) { ------------------ | Branch (30665:21): [True: 0, False: 0] ------------------ 30666| 0| janet_buffer_push_cstring(buffer, reg->name_prefix); 30667| 0| janet_buffer_push_u8(buffer, '/'); 30668| 0| } 30669| 0| janet_buffer_push_cstring(buffer, reg->name); 30670| 0| janet_buffer_push_u8(buffer, '>'); 30671| 0| break; 30672| 0| } 30673| 0| goto fallthrough; 30674| 0| } 30675| 269| case JANET_FUNCTION: { ------------------ | Branch (30675:9): [True: 269, False: 700k] ------------------ 30676| 269| JanetFunction *fun = janet_unwrap_function(x); ------------------ | | 868| 269|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 30677| 269| JanetFuncDef *def = fun->def; 30678| 269| if (def == NULL) { ------------------ | Branch (30678:17): [True: 0, False: 269] ------------------ 30679| 0| janet_buffer_push_cstring(buffer, ""); 30680| 0| break; 30681| 0| } 30682| 269| if (def->name) { ------------------ | Branch (30682:17): [True: 269, False: 0] ------------------ 30683| 269| const uint8_t *n = def->name; 30684| 269| janet_buffer_push_cstring(buffer, "length) | | ------------------ | | | | 1812| 269|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30686| 269| janet_buffer_push_u8(buffer, '>'); 30687| 269| break; 30688| 269| } 30689| 0| goto fallthrough; 30690| 269| } 30691| 0| fallthrough: 30692| 124| default: ------------------ | Branch (30692:9): [True: 124, False: 700k] ------------------ 30693| 124| string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 795| 124| (isnan((x).number) \ | | 796| 124| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 124| : JANET_NUMBER) ------------------ string_description_b(buffer, janet_type_names[janet_type(x)], janet_unwrap_pointer(x)); ------------------ | | 867| 124|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (30693:59): [True: 124, False: 0] ------------------ 30694| 124| break; 30695| 700k| } 30696| 700k|} janet_description_b: 30711| 814k|void janet_description_b(JanetBuffer *buffer, Janet x) { 30712| 814k| switch (janet_type(x)) { ------------------ | | 795| 814k| (isnan((x).number) \ | | 796| 814k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 814k| : JANET_NUMBER) ------------------ | Branch (30712:13): [True: 795k, False: 19.0k] ------------------ 30713| 694k| default: ------------------ | Branch (30713:9): [True: 694k, False: 120k] ------------------ 30714| 694k| break; 30715| 694k| case JANET_NIL: ------------------ | Branch (30715:9): [True: 472, False: 814k] ------------------ 30716| 472| janet_buffer_push_cstring(buffer, "nil"); 30717| 472| return; 30718| 559| case JANET_KEYWORD: ------------------ | Branch (30718:9): [True: 559, False: 814k] ------------------ 30719| 559| janet_buffer_push_u8(buffer, ':'); 30720| 559| break; 30721| 119k| case JANET_STRING: ------------------ | Branch (30721:9): [True: 119k, False: 695k] ------------------ 30722| 119k| janet_escape_string_b(buffer, janet_unwrap_string(x)); ------------------ | | 863| 119k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 30723| 119k| return; 30724| 49| case JANET_BUFFER: { ------------------ | Branch (30724:9): [True: 49, False: 814k] ------------------ 30725| 49| JanetBuffer *b = janet_unwrap_buffer(x); ------------------ | | 862| 49|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 30726| 49| janet_escape_buffer_b(buffer, b); 30727| 49| return; 30728| 0| } 30729| 144| case JANET_ABSTRACT: { ------------------ | Branch (30729:9): [True: 144, False: 814k] ------------------ 30730| 144| JanetAbstract p = janet_unwrap_abstract(x); ------------------ | | 866| 144|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30731| 144| const JanetAbstractType *t = janet_abstract_type(p); ------------------ | | 1899| 144|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 144|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 30732| 144| if (t->tostring != NULL) { ------------------ | Branch (30732:17): [True: 144, False: 0] ------------------ 30733| 144| janet_buffer_push_cstring(buffer, "<"); 30734| 144| janet_buffer_push_cstring(buffer, t->name); 30735| 144| janet_buffer_push_cstring(buffer, " "); 30736| 144| t->tostring(p, buffer); 30737| 144| janet_buffer_push_cstring(buffer, ">"); 30738| 144| } else { 30739| 0| string_description_b(buffer, t->name, p); 30740| 0| } 30741| 144| return; 30742| 0| } 30743| 814k| } 30744| 694k| janet_to_string_b(buffer, x); 30745| 694k|} janet_formatbv: 31398| 89.5k|void janet_formatbv(JanetBuffer *b, const char *format, va_list args) { 31399| 89.5k| const char *format_end = format + strlen(format); 31400| 89.5k| const char *c = format; 31401| 89.5k| int32_t startlen = b->count; 31402| 3.22M| while (c < format_end) { ------------------ | Branch (31402:12): [True: 3.13M, False: 89.5k] ------------------ 31403| 3.13M| if (*c != '%') { ------------------ | Branch (31403:13): [True: 3.03M, False: 93.3k] ------------------ 31404| 3.03M| janet_buffer_push_u8(b, (uint8_t) *c++); 31405| 3.03M| } else if (*++c == '%') { ------------------ | Branch (31405:20): [True: 0, False: 93.3k] ------------------ 31406| 0| janet_buffer_push_u8(b, (uint8_t) *c++); 31407| 93.3k| } else { 31408| 93.3k| char form[MAX_FORMAT], item[MAX_ITEM]; 31409| 93.3k| char width[3], precision[3]; 31410| 93.3k| int nb = 0; /* number of bytes in added item */ 31411| 93.3k| c = scanformat(c, form, width, precision); 31412| 93.3k| switch (*c++) { 31413| 0| case 'c': { ------------------ | Branch (31413:17): [True: 0, False: 93.3k] ------------------ 31414| 0| int n = va_arg(args, int); 31415| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31416| 0| break; 31417| 0| } 31418| 1.05k| case 'd': ------------------ | Branch (31418:17): [True: 1.05k, False: 92.3k] ------------------ 31419| 1.05k| case 'i': { ------------------ | Branch (31419:17): [True: 0, False: 93.3k] ------------------ 31420| 1.05k| int64_t n = (int64_t) va_arg(args, int32_t); 31421| 1.05k| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 1.05k|#define MAX_ITEM 256 ------------------ 31422| 1.05k| break; 31423| 1.05k| } 31424| 0| case 'D': ------------------ | Branch (31424:17): [True: 0, False: 93.3k] ------------------ 31425| 0| case 'I': { ------------------ | Branch (31425:17): [True: 0, False: 93.3k] ------------------ 31426| 0| int64_t n = va_arg(args, int64_t); 31427| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31428| 0| break; 31429| 0| } 31430| 0| case 'x': ------------------ | Branch (31430:17): [True: 0, False: 93.3k] ------------------ 31431| 0| case 'X': ------------------ | Branch (31431:17): [True: 0, False: 93.3k] ------------------ 31432| 0| case 'o': ------------------ | Branch (31432:17): [True: 0, False: 93.3k] ------------------ 31433| 0| case 'u': { ------------------ | Branch (31433:17): [True: 0, False: 93.3k] ------------------ 31434| 0| uint64_t n = va_arg(args, uint64_t); 31435| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31436| 0| break; 31437| 0| } 31438| 0| case 'a': ------------------ | Branch (31438:17): [True: 0, False: 93.3k] ------------------ 31439| 0| case 'A': ------------------ | Branch (31439:17): [True: 0, False: 93.3k] ------------------ 31440| 0| case 'e': ------------------ | Branch (31440:17): [True: 0, False: 93.3k] ------------------ 31441| 0| case 'E': ------------------ | Branch (31441:17): [True: 0, False: 93.3k] ------------------ 31442| 0| case 'f': ------------------ | Branch (31442:17): [True: 0, False: 93.3k] ------------------ 31443| 0| case 'g': ------------------ | Branch (31443:17): [True: 0, False: 93.3k] ------------------ 31444| 0| case 'G': { ------------------ | Branch (31444:17): [True: 0, False: 93.3k] ------------------ 31445| 0| double d = va_arg(args, double); 31446| 0| nb = snprintf(item, MAX_ITEM, form, d); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31447| 0| break; 31448| 0| } 31449| 625| case 's': ------------------ | Branch (31449:17): [True: 625, False: 92.7k] ------------------ 31450| 625| case 'S': { ------------------ | Branch (31450:17): [True: 0, False: 93.3k] ------------------ 31451| 625| const char *str = va_arg(args, const char *); 31452| 625| int32_t len = (c[-1] == 's') ------------------ | Branch (31452:35): [True: 625, False: 0] ------------------ 31453| 625| ? (int32_t) strlen(str) 31454| 625| : janet_string_length((JanetString) str); ------------------ | | 1813| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 31455| 625| if (form[2] == '\0') ------------------ | Branch (31455:25): [True: 625, False: 0] ------------------ 31456| 625| janet_buffer_push_bytes(b, (const uint8_t *) str, len); 31457| 0| else { 31458| 0| if (len != (int32_t) strlen((const char *) str)) ------------------ | Branch (31458:29): [True: 0, False: 0] ------------------ 31459| 0| janet_panic("string contains zeros"); 31460| 0| if (!strchr(form, '.') && len >= 100) { ------------------ | Branch (31460:29): [True: 0, False: 0] | Branch (31460:51): [True: 0, False: 0] ------------------ 31461| 0| janet_panic("no precision and string is too long to be formatted"); 31462| 0| } else { 31463| 0| nb = snprintf(item, MAX_ITEM, form, str); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31464| 0| } 31465| 0| } 31466| 625| break; 31467| 625| } 31468| 2.72k| case 'V': ------------------ | Branch (31468:17): [True: 2.72k, False: 90.6k] ------------------ 31469| 2.72k| janet_to_string_b(b, va_arg(args, Janet)); 31470| 2.72k| break; 31471| 76.7k| case 'v': ------------------ | Branch (31471:17): [True: 76.7k, False: 16.6k] ------------------ 31472| 76.7k| janet_description_b(b, va_arg(args, Janet)); 31473| 76.7k| break; 31474| 0| case 't': ------------------ | Branch (31474:17): [True: 0, False: 93.3k] ------------------ 31475| 0| janet_buffer_push_cstring(b, typestr(va_arg(args, Janet))); 31476| 0| break; 31477| 2.14k| case 'T': { ------------------ | Branch (31477:17): [True: 2.14k, False: 91.2k] ------------------ 31478| 2.14k| int types = va_arg(args, int); 31479| 2.14k| pushtypes(b, types); 31480| 2.14k| break; 31481| 625| } 31482| 0| case 'M': ------------------ | Branch (31482:17): [True: 0, False: 93.3k] ------------------ 31483| 0| case 'm': ------------------ | Branch (31483:17): [True: 0, False: 93.3k] ------------------ 31484| 0| case 'N': ------------------ | Branch (31484:17): [True: 0, False: 93.3k] ------------------ 31485| 0| case 'n': ------------------ | Branch (31485:17): [True: 0, False: 93.3k] ------------------ 31486| 0| case 'Q': ------------------ | Branch (31486:17): [True: 0, False: 93.3k] ------------------ 31487| 10.0k| case 'q': ------------------ | Branch (31487:17): [True: 10.0k, False: 83.3k] ------------------ 31488| 10.0k| case 'P': ------------------ | Branch (31488:17): [True: 0, False: 93.3k] ------------------ 31489| 10.0k| case 'p': { /* janet pretty , precision = depth */ ------------------ | Branch (31489:17): [True: 0, False: 93.3k] ------------------ 31490| 10.0k| int depth = atoi(precision); 31491| 10.0k| if (depth < 1) depth = JANET_RECURSION_GUARD; ------------------ | | 296| 10.0k|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (31491:25): [True: 10.0k, False: 0] ------------------ 31492| 10.0k| char d = c[-1]; 31493| 10.0k| int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); ------------------ | Branch (31493:37): [True: 0, False: 10.0k] | Branch (31493:51): [True: 0, False: 10.0k] | Branch (31493:65): [True: 0, False: 10.0k] | Branch (31493:79): [True: 0, False: 10.0k] ------------------ 31494| 10.0k| int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); ------------------ | Branch (31494:39): [True: 0, False: 10.0k] | Branch (31494:53): [True: 10.0k, False: 0] | Branch (31494:67): [True: 0, False: 0] | Branch (31494:81): [True: 0, False: 0] ------------------ 31495| 10.0k| int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); ------------------ | Branch (31495:39): [True: 0, False: 10.0k] | Branch (31495:53): [True: 0, False: 10.0k] | Branch (31495:67): [True: 0, False: 10.0k] | Branch (31495:81): [True: 0, False: 10.0k] ------------------ 31496| 10.0k| int columns = atoi(width); 31497| 10.0k| if (columns == 0) { ------------------ | Branch (31497:25): [True: 10.0k, False: 0] ------------------ 31498| 10.0k| columns = JANET_COLUMNS; ------------------ | |31234| 10.0k|#define JANET_COLUMNS 80 ------------------ 31499| 10.0k| } else if (columns < 0) { ------------------ | Branch (31499:32): [True: 0, False: 0] ------------------ 31500| 0| has_oneline = 1; 31501| 0| } 31502| 10.0k| int flags = 0; 31503| 10.0k| flags |= has_color ? JANET_PRETTY_COLOR : 0; ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31503:30): [True: 0, False: 10.0k] ------------------ 31504| 10.0k| flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; ------------------ | | 1968| 10.0k|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (31504:30): [True: 10.0k, False: 0] ------------------ 31505| 10.0k| flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; ------------------ | | 1969| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31505:30): [True: 0, False: 10.0k] ------------------ 31506| 10.0k| janet_pretty_(b, depth, columns, flags, 31507| 10.0k| va_arg(args, Janet), startlen, b->count); 31508| 10.0k| break; 31509| 10.0k| } 31510| 0| case 'j': { ------------------ | Branch (31510:17): [True: 0, False: 93.3k] ------------------ 31511| 0| int depth = atoi(precision); 31512| 0| if (depth < 1) { ------------------ | Branch (31512:25): [True: 0, False: 0] ------------------ 31513| 0| depth = JANET_RECURSION_GUARD; ------------------ | | 296| 0|#define JANET_RECURSION_GUARD 1024 ------------------ 31514| 0| } 31515| 0| janet_jdn_(b, depth, va_arg(args, Janet), startlen, b->count); 31516| 0| break; 31517| 10.0k| } 31518| 0| default: { ------------------ | Branch (31518:17): [True: 0, False: 93.3k] ------------------ 31519| | /* also treat cases 'nLlh' */ 31520| 0| janet_panicf("invalid conversion '%s' to 'format'", 31521| 0| form); 31522| 10.0k| } 31523| 93.3k| } 31524| 93.3k| if (nb >= MAX_ITEM) ------------------ | |31321| 93.3k|#define MAX_ITEM 256 ------------------ | Branch (31524:17): [True: 0, False: 93.3k] ------------------ 31525| 0| janet_panic("format buffer overflow"); 31526| 93.3k| if (nb > 0) ------------------ | Branch (31526:17): [True: 1.05k, False: 92.3k] ------------------ 31527| 1.05k| janet_buffer_push_bytes(b, (uint8_t *) item, nb); 31528| 93.3k| } 31529| | 31530| 3.13M| } 31531| 89.5k|} janet_formatc: 31535| 86.8k|const uint8_t *janet_formatc(const char *format, ...) { 31536| 86.8k| va_list args; 31537| 86.8k| const uint8_t *ret; 31538| 86.8k| JanetBuffer buffer; 31539| 86.8k| int32_t len = 0; 31540| | 31541| | /* Calculate length, init buffer and args */ 31542| 3.24M| while (format[len]) len++; ------------------ | Branch (31542:12): [True: 3.16M, False: 86.8k] ------------------ 31543| 86.8k| janet_buffer_init(&buffer, len); 31544| 86.8k| va_start(args, format); 31545| | 31546| | /* Run format */ 31547| 86.8k| janet_formatbv(&buffer, format, args); 31548| | 31549| | /* Iterate length */ 31550| 86.8k| va_end(args); 31551| | 31552| 86.8k| ret = janet_string(buffer.data, buffer.count); 31553| 86.8k| janet_buffer_deinit(&buffer); 31554| 86.8k| return ret; 31555| 86.8k|} janet_formatb: 31557| 3|JanetBuffer *janet_formatb(JanetBuffer *buffer, const char *format, ...) { 31558| 3| va_list args; 31559| 3| va_start(args, format); 31560| 3| janet_formatbv(buffer, format, args); 31561| | va_end(args); 31562| 3| return buffer; 31563| 3|} janet_buffer_format: 31572| 44.1k| Janet *argv) { 31573| 44.1k| size_t sfl = strlen(strfrmt); 31574| 44.1k| const char *strfrmt_end = strfrmt + sfl; 31575| 44.1k| int32_t arg = argstart; 31576| 44.1k| int32_t startlen = b->count; 31577| 88.5k| while (strfrmt < strfrmt_end) { ------------------ | Branch (31577:12): [True: 44.3k, False: 44.1k] ------------------ 31578| 44.3k| if (*strfrmt != '%') ------------------ | Branch (31578:13): [True: 168, False: 44.1k] ------------------ 31579| 168| janet_buffer_push_u8(b, (uint8_t) * strfrmt++); 31580| 44.1k| else if (*++strfrmt == '%') ------------------ | Branch (31580:18): [True: 0, False: 44.1k] ------------------ 31581| 0| janet_buffer_push_u8(b, (uint8_t) * strfrmt++); /* %% */ 31582| 44.1k| else { /* format item */ 31583| 44.1k| char form[MAX_FORMAT], item[MAX_ITEM]; 31584| 44.1k| char width[3], precision[3]; 31585| 44.1k| int nb = 0; /* number of bytes in added item */ 31586| |#ifdef JANET_PLAN9 31587| | if (*strfrmt == 'r') { 31588| | rerrstr(item, MAX_ITEM); 31589| | nb = strlen(item); 31590| | } else 31591| |#endif 31592| 44.1k| if (++arg >= argc) ------------------ | Branch (31592:21): [True: 0, False: 44.1k] ------------------ 31593| 0| janet_panic("not enough values for format"); 31594| 44.1k| strfrmt = scanformat(strfrmt, form, width, precision); 31595| 44.1k| switch (*strfrmt++) { 31596| |#ifdef JANET_PLAN9 31597| | case 'r': 31598| | break; 31599| |#endif 31600| 0| case 'c': { ------------------ | Branch (31600:17): [True: 0, False: 44.1k] ------------------ 31601| 0| nb = snprintf(item, MAX_ITEM, form, (int) ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31602| 0| janet_getinteger(argv, arg)); 31603| 0| break; 31604| 0| } 31605| 0| case 'D': ------------------ | Branch (31605:17): [True: 0, False: 44.1k] ------------------ 31606| 0| case 'I': ------------------ | Branch (31606:17): [True: 0, False: 44.1k] ------------------ 31607| 0| case 'd': ------------------ | Branch (31607:17): [True: 0, False: 44.1k] ------------------ 31608| 0| case 'i': { ------------------ | Branch (31608:17): [True: 0, False: 44.1k] ------------------ 31609| 0| int64_t n = janet_getinteger64(argv, arg); 31610| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31611| 0| break; 31612| 0| } 31613| 0| case 'x': ------------------ | Branch (31613:17): [True: 0, False: 44.1k] ------------------ 31614| 0| case 'X': ------------------ | Branch (31614:17): [True: 0, False: 44.1k] ------------------ 31615| 0| case 'o': ------------------ | Branch (31615:17): [True: 0, False: 44.1k] ------------------ 31616| 0| case 'u': { ------------------ | Branch (31616:17): [True: 0, False: 44.1k] ------------------ 31617| 0| uint64_t n = janet_getuinteger64(argv, arg); 31618| 0| nb = snprintf(item, MAX_ITEM, form, n); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31619| 0| break; 31620| 0| } 31621| 0| case 'a': ------------------ | Branch (31621:17): [True: 0, False: 44.1k] ------------------ 31622| 0| case 'A': ------------------ | Branch (31622:17): [True: 0, False: 44.1k] ------------------ 31623| 0| case 'e': ------------------ | Branch (31623:17): [True: 0, False: 44.1k] ------------------ 31624| 0| case 'E': ------------------ | Branch (31624:17): [True: 0, False: 44.1k] ------------------ 31625| 0| case 'f': ------------------ | Branch (31625:17): [True: 0, False: 44.1k] ------------------ 31626| 0| case 'g': ------------------ | Branch (31626:17): [True: 0, False: 44.1k] ------------------ 31627| 0| case 'G': { ------------------ | Branch (31627:17): [True: 0, False: 44.1k] ------------------ 31628| 0| double d = janet_getnumber(argv, arg); 31629| 0| nb = snprintf(item, MAX_ITEM, form, d); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31630| 0| break; 31631| 0| } 31632| 2| case 's': { ------------------ | Branch (31632:17): [True: 2, False: 44.1k] ------------------ 31633| 2| const char *s = janet_getcbytes(argv, arg); 31634| 2| if (form[2] == '\0') ------------------ | Branch (31634:25): [True: 2, False: 0] ------------------ 31635| 2| janet_buffer_push_cstring(b, s); 31636| 0| else { 31637| 0| nb = snprintf(item, MAX_ITEM, form, s); ------------------ | |31321| 0|#define MAX_ITEM 256 ------------------ 31638| 0| } 31639| 2| break; 31640| 0| } 31641| 0| case 'V': { ------------------ | Branch (31641:17): [True: 0, False: 44.1k] ------------------ 31642| 0| janet_to_string_b(b, argv[arg]); 31643| 0| break; 31644| 0| } 31645| 0| case 'v': { ------------------ | Branch (31645:17): [True: 0, False: 44.1k] ------------------ 31646| 0| janet_description_b(b, argv[arg]); 31647| 0| break; 31648| 0| } 31649| 0| case 't': ------------------ | Branch (31649:17): [True: 0, False: 44.1k] ------------------ 31650| 0| janet_buffer_push_cstring(b, typestr(argv[arg])); 31651| 0| break; 31652| 0| case 'M': ------------------ | Branch (31652:17): [True: 0, False: 44.1k] ------------------ 31653| 0| case 'm': ------------------ | Branch (31653:17): [True: 0, False: 44.1k] ------------------ 31654| 0| case 'N': ------------------ | Branch (31654:17): [True: 0, False: 44.1k] ------------------ 31655| 6| case 'n': ------------------ | Branch (31655:17): [True: 6, False: 44.1k] ------------------ 31656| 6| case 'Q': ------------------ | Branch (31656:17): [True: 0, False: 44.1k] ------------------ 31657| 6| case 'q': ------------------ | Branch (31657:17): [True: 0, False: 44.1k] ------------------ 31658| 6| case 'P': ------------------ | Branch (31658:17): [True: 0, False: 44.1k] ------------------ 31659| 6| case 'p': { /* janet pretty , precision = depth */ ------------------ | Branch (31659:17): [True: 0, False: 44.1k] ------------------ 31660| 6| int depth = atoi(precision); 31661| 6| if (depth < 1) depth = JANET_RECURSION_GUARD; ------------------ | | 296| 6|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (31661:25): [True: 6, False: 0] ------------------ 31662| 6| char d = strfrmt[-1]; 31663| 6| int has_color = (d == 'P') || (d == 'Q') || (d == 'M') || (d == 'N'); ------------------ | Branch (31663:37): [True: 0, False: 6] | Branch (31663:51): [True: 0, False: 6] | Branch (31663:65): [True: 0, False: 6] | Branch (31663:79): [True: 0, False: 6] ------------------ 31664| 6| int has_oneline = (d == 'Q') || (d == 'q') || (d == 'N') || (d == 'n'); ------------------ | Branch (31664:39): [True: 0, False: 6] | Branch (31664:53): [True: 0, False: 6] | Branch (31664:67): [True: 0, False: 6] | Branch (31664:81): [True: 6, False: 0] ------------------ 31665| 6| int has_notrunc = (d == 'M') || (d == 'm') || (d == 'N') || (d == 'n'); ------------------ | Branch (31665:39): [True: 0, False: 6] | Branch (31665:53): [True: 0, False: 6] | Branch (31665:67): [True: 0, False: 6] | Branch (31665:81): [True: 6, False: 0] ------------------ 31666| 6| int columns = atoi(width); 31667| 6| if (columns == 0) ------------------ | Branch (31667:25): [True: 6, False: 0] ------------------ 31668| 6| columns = JANET_COLUMNS; ------------------ | |31234| 6|#define JANET_COLUMNS 80 ------------------ 31669| 0| else if (columns < 0) ------------------ | Branch (31669:30): [True: 0, False: 0] ------------------ 31670| 0| has_oneline = 1; 31671| 6| int flags = 0; 31672| 6| flags |= has_color ? JANET_PRETTY_COLOR : 0; ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31672:30): [True: 0, False: 6] ------------------ 31673| 6| flags |= has_oneline ? JANET_PRETTY_ONELINE : 0; ------------------ | | 1968| 6|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (31673:30): [True: 6, False: 0] ------------------ 31674| 6| flags |= has_notrunc ? JANET_PRETTY_NOTRUNC : 0; ------------------ | | 1969| 6|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31674:30): [True: 6, False: 0] ------------------ 31675| 6| janet_pretty_(b, depth, columns, flags, 31676| 6| argv[arg], startlen, b->count); 31677| 6| break; 31678| 6| } 31679| 44.1k| case 'j': { ------------------ | Branch (31679:17): [True: 44.1k, False: 8] ------------------ 31680| 44.1k| int depth = atoi(precision); 31681| 44.1k| if (depth < 1) ------------------ | Branch (31681:25): [True: 44.1k, False: 0] ------------------ 31682| 44.1k| depth = JANET_RECURSION_GUARD; ------------------ | | 296| 44.1k|#define JANET_RECURSION_GUARD 1024 ------------------ 31683| 44.1k| janet_jdn_(b, depth, argv[arg], startlen, b->count); 31684| 44.1k| break; 31685| 6| } 31686| 0| default: { ------------------ | Branch (31686:17): [True: 0, False: 44.1k] ------------------ 31687| | /* also treat cases 'nLlh' */ 31688| 0| janet_panicf("invalid conversion '%s' to 'format'", 31689| 0| form); 31690| 6| } 31691| 44.1k| } 31692| 44.1k| if (nb >= MAX_ITEM) ------------------ | |31321| 44.1k|#define MAX_ITEM 256 ------------------ | Branch (31692:17): [True: 0, False: 44.1k] ------------------ 31693| 0| janet_panic("format buffer overflow"); 31694| 44.1k| if (nb > 0) ------------------ | Branch (31694:17): [True: 0, False: 44.1k] ------------------ 31695| 0| janet_buffer_push_bytes(b, (uint8_t *) item, nb); 31696| 44.1k| } 31697| 44.3k| } 31698| 44.1k|} janetc_regalloc_init: 31738| 428k|void janetc_regalloc_init(JanetcRegisterAllocator *ra) { 31739| | ra->chunks = NULL; 31740| 428k| ra->count = 0; 31741| 428k| ra->capacity = 0; 31742| 428k| ra->max = 0; 31743| 428k| ra->regtemps = 0; 31744| 428k|} janetc_regalloc_deinit: 31746| 449k|void janetc_regalloc_deinit(JanetcRegisterAllocator *ra) { 31747| 449k| janet_free(ra->chunks); ------------------ | | 2415| 449k|#define janet_free(X) free((X)) ------------------ 31748| 449k|} janetc_regalloc_clone: 31773| 20.5k|void janetc_regalloc_clone(JanetcRegisterAllocator *dest, JanetcRegisterAllocator *src) { 31774| 20.5k| size_t size; 31775| 20.5k| dest->count = src->count; 31776| 20.5k| dest->capacity = src->capacity; 31777| 20.5k| dest->max = src->max; 31778| 20.5k| size = sizeof(uint32_t) * (size_t) dest->capacity; 31779| 20.5k| dest->regtemps = 0; 31780| 20.5k| if (size) { ------------------ | Branch (31780:9): [True: 12.6k, False: 7.90k] ------------------ 31781| 12.6k| dest->chunks = janet_malloc(size); ------------------ | | 2406| 12.6k|#define janet_malloc(X) malloc((X)) ------------------ 31782| 12.6k| if (!dest->chunks) { ------------------ | Branch (31782:13): [True: 0, False: 12.6k] ------------------ 31783| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 31784| 0| } 31785| 12.6k| memcpy(dest->chunks, src->chunks, size); 31786| 12.6k| } else { 31787| | dest->chunks = NULL; 31788| 7.90k| } 31789| 20.5k|} janetc_regalloc_touch: 31809| 144k|void janetc_regalloc_touch(JanetcRegisterAllocator *ra, int32_t reg) { 31810| 144k| int32_t chunk = reg >> 5; 31811| 144k| int32_t bit = reg & 0x1F; 31812| 219k| while (chunk >= ra->count) pushchunk(ra); ------------------ | Branch (31812:12): [True: 74.9k, False: 144k] ------------------ 31813| 144k| ra->chunks[chunk] |= ithbit(bit); ------------------ | |31767| 144k|#define ithbit(I) ((uint32_t)1 << (I)) ------------------ 31814| 144k|} janetc_regalloc_1: 31817| 14.4M|int32_t janetc_regalloc_1(JanetcRegisterAllocator *ra) { 31818| | /* Get the nth bit in the array */ 31819| 14.4M| int32_t bit, chunk, nchunks, reg; 31820| 14.4M| bit = -1; 31821| 14.4M| nchunks = ra->count; 31822| 18.0G| for (chunk = 0; chunk < nchunks; chunk++) { ------------------ | Branch (31822:21): [True: 18.0G, False: 494k] ------------------ 31823| 18.0G| uint32_t block = ra->chunks[chunk]; 31824| 18.0G| if (block == 0xFFFFFFFF) continue; ------------------ | Branch (31824:13): [True: 18.0G, False: 13.9M] ------------------ 31825| 13.9M| bit = count_trailing_ones(block); ------------------ | |31753| 13.9M|#define count_trailing_ones(x) __builtin_ctz(~(x)) ------------------ 31826| 13.9M| break; 31827| 18.0G| } 31828| | /* No reg found */ 31829| 14.4M| if (bit == -1) { ------------------ | Branch (31829:9): [True: 494k, False: 13.9M] ------------------ 31830| 494k| pushchunk(ra); 31831| 494k| bit = 0; 31832| 494k| chunk = nchunks; 31833| 494k| } 31834| | /* set the bit at index bit in chunk */ 31835| 14.4M| ra->chunks[chunk] |= ithbit(bit); ------------------ | |31767| 14.4M|#define ithbit(I) ((uint32_t)1 << (I)) ------------------ 31836| 14.4M| reg = (chunk << 5) + bit; 31837| 14.4M| if (reg > ra->max) ------------------ | Branch (31837:9): [True: 10.8M, False: 3.64M] ------------------ 31838| 10.8M| ra->max = reg; 31839| 14.4M| return reg; 31840| 14.4M|} janetc_regalloc_free: 31867| 4.29M|void janetc_regalloc_free(JanetcRegisterAllocator *ra, int32_t reg) { 31868| 4.29M| int32_t chunk = reg >> 5; 31869| 4.29M| int32_t bit = reg & 0x1F; 31870| 4.29M| ra->chunks[chunk] &= ~ithbit(bit); ------------------ | |31767| 4.29M|#define ithbit(I) ((uint32_t)1 << (I)) ------------------ 31871| 4.29M|} janetc_regalloc_temp: 31888| 8.35M|int32_t janetc_regalloc_temp(JanetcRegisterAllocator *ra, JanetcRegisterTemp nth) { 31889| 8.35M| int32_t oldmax = ra->max; 31890| 8.35M| if (ra->regtemps & (1 << nth)) { ------------------ | Branch (31890:9): [True: 0, False: 8.35M] ------------------ 31891| 0| JANET_EXIT("regtemp already allocated"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 31892| 0| } 31893| 8.35M| ra->regtemps |= 1 << nth; 31894| 8.35M| int32_t reg = janetc_regalloc_1(ra); 31895| 8.35M| if (reg > 0xFF) { ------------------ | Branch (31895:9): [True: 7.91M, False: 440k] ------------------ 31896| 7.91M| reg = 0xF0 + nth; 31897| 7.91M| ra->max = (reg > oldmax) ? reg : oldmax; ------------------ | Branch (31897:19): [True: 229, False: 7.91M] ------------------ 31898| 7.91M| } 31899| 8.35M| return reg; 31900| 8.35M|} janetc_regalloc_freetemp: 31902| 9.31M|void janetc_regalloc_freetemp(JanetcRegisterAllocator *ra, int32_t reg, JanetcRegisterTemp nth) { 31903| 9.31M| ra->regtemps &= ~(1 << nth); 31904| 9.31M| if (reg < 0xF0) ------------------ | Branch (31904:9): [True: 554k, False: 8.75M] ------------------ 31905| 554k| janetc_regalloc_free(ra, reg); 31906| 9.31M|} dohead_destructure: 32456| 287k|SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopts opts, Janet lhs, Janet rhs) { 32457| 287k| if (c->recursion_guard <= 0) { ------------------ | Branch (32457:9): [True: 0, False: 287k] ------------------ 32458| 0| janetc_error(c, janet_cstring("C stack recursed too deeply")); 32459| 0| return NULL; 32460| 0| } 32461| | /* Detect if we can do an optimization to avoid some allocations */ 32462| 287k| int can_destructure_lhs = janet_checktype(lhs, JANET_TUPLE) ------------------ | | 806| 575k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 160k, False: 127k] | | | Branch (806:6): [Folded, False: 287k] | | ------------------ | | 807| 575k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 575k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 287k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 287k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 287k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 287k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32463| 127k| || janet_checktype(lhs, JANET_ARRAY); ------------------ | | 806| 127k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1, False: 127k] | | | Branch (806:6): [Folded, False: 127k] | | ------------------ | | 807| 127k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 127k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 127k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 127k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 127k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 127k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32464| 287k| int rhs_is_indexed = janet_checktype(rhs, JANET_ARRAY) ------------------ | | 806| 575k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2, False: 287k] | | | Branch (806:6): [Folded, False: 287k] | | ------------------ | | 807| 575k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 575k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 287k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 287k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 287k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 287k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32465| 287k| || (janet_checktype(rhs, JANET_TUPLE) && (janet_tuple_flag(janet_unwrap_tuple(rhs)) & JANET_TUPLE_FLAG_BRACKETCTOR)); ------------------ | | 806| 575k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 8.66k, False: 279k] | | | Branch (806:6): [Folded, False: 287k] | | ------------------ | | 807| 575k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 575k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 287k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 287k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 287k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 287k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ || (janet_checktype(rhs, JANET_TUPLE) && (janet_tuple_flag(janet_unwrap_tuple(rhs)) & JANET_TUPLE_FLAG_BRACKETCTOR)); ------------------ | | 1806| 8.66k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 8.66k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ || (janet_checktype(rhs, JANET_TUPLE) && (janet_tuple_flag(janet_unwrap_tuple(rhs)) & JANET_TUPLE_FLAG_BRACKETCTOR)); ------------------ | | 1798| 8.66k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (32465:67): [True: 944, False: 7.72k] ------------------ 32466| 287k| uint32_t has_drop = opts.flags & JANET_FOPTS_DROP; ------------------ | | 1149| 287k|#define JANET_FOPTS_DROP 0x40000 ------------------ 32467| | 32468| 287k| JanetFopts subopts = janetc_fopts_default(c); 32469| 287k| subopts.flags = opts.flags & ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); ------------------ | | 1147| 287k|#define JANET_FOPTS_TAIL 0x10000 ------------------ subopts.flags = opts.flags & ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); ------------------ | | 1149| 287k|#define JANET_FOPTS_DROP 0x40000 ------------------ 32470| | 32471| 287k| if (has_drop && can_destructure_lhs && rhs_is_indexed) { ------------------ | Branch (32471:9): [True: 102k, False: 185k] | Branch (32471:21): [True: 1.40k, False: 100k] | Branch (32471:44): [True: 910, False: 496] ------------------ 32472| | /* Code is of the form (def [a b] [1 2]), avoid the allocation of two tuples */ 32473| 910| JanetView view_lhs = {0}; 32474| 910| JanetView view_rhs = {0}; 32475| 910| janet_indexed_view(lhs, &view_lhs.items, &view_lhs.len); 32476| 910| janet_indexed_view(rhs, &view_rhs.items, &view_rhs.len); 32477| 910| int found_amp = 0; 32478| 910| int found_splice = 0; 32479| | /* Check for (def [x y z] [(splice [1 2 3]) 4 5 6]), bail out of optimization */ 32480| 3.09k| for (int32_t i = 0; i < view_rhs.len; i++) { ------------------ | Branch (32480:29): [True: 2.19k, False: 909] ------------------ 32481| 2.19k| if (!janet_checktype(view_rhs.items[i], JANET_TUPLE)) { ------------------ | | 806| 2.19k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.19k] | | ------------------ | | 807| 2.19k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.19k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.19k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.19k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.19k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.19k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32481:17): [True: 910, False: 1.28k] ------------------ 32482| 910| continue; 32483| 910| } 32484| 1.28k| JanetTuple tup = janet_unwrap_tuple(view_rhs.items[i]); ------------------ | | 858| 1.28k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 32485| 1.28k| if (janet_tuple_length(tup) == 0) { ------------------ | | 1802| 1.28k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 1.28k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (32485:17): [True: 0, False: 1.28k] ------------------ 32486| 0| continue; 32487| 0| } 32488| 1.28k| if (janet_symeq(tup[0], "splice")) { ------------------ | Branch (32488:17): [True: 1, False: 1.27k] ------------------ 32489| 1| found_splice = 1; 32490| | /* Good error will be generated later. */ 32491| 1| break; 32492| 1| } 32493| 1.28k| } 32494| | /* Check for (def [x & more] [1 2 3]), bail out of optimization */ 32495| 186k| for (int32_t i = 0; i < view_lhs.len; i++) { ------------------ | Branch (32495:29): [True: 185k, False: 910] ------------------ 32496| 185k| if (janet_symeq(view_lhs.items[i], "&")) { ------------------ | Branch (32496:17): [True: 0, False: 185k] ------------------ 32497| 0| found_amp = 1; 32498| | /* Good error will be generated later. */ 32499| 0| break; 32500| 0| } 32501| 185k| } 32502| 910| if (!found_amp && !found_splice) { ------------------ | Branch (32502:13): [True: 910, False: 0] | Branch (32502:27): [True: 909, False: 1] ------------------ 32503| 186k| for (int32_t i = 0; i < view_lhs.len; i++) { ------------------ | Branch (32503:33): [True: 185k, False: 909] ------------------ 32504| 185k| Janet sub_rhs = view_rhs.len <= i ? janet_wrap_nil() : view_rhs.items[i]; ------------------ | | 831| 183k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 183k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 183k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 183k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32504:33): [True: 183k, False: 1.81k] ------------------ 32505| 185k| c->recursion_guard--; 32506| 185k| into = dohead_destructure(c, into, subopts, view_lhs.items[i], sub_rhs); 32507| 185k| c->recursion_guard++; 32508| 185k| } 32509| 909| return into; 32510| 909| } 32511| 910| } 32512| | 32513| | /* No optimization, do the simple way */ 32514| 287k| subopts.hint = opts.hint; 32515| 287k| JanetSlot ret = janetc_value(subopts, rhs); 32516| 287k| SlotHeadPair shp = {lhs, ret}; 32517| | janet_v_push(into, shp); ------------------ | | 757| 287k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 287k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 287k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 184k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 184k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 184k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 184k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 102k, False: 184k] | | | | | | | Branch (768:50): [True: 6.77k, False: 177k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 109k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 287k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 287k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 32518| 287k| return into; 32519| 287k|} janetc_special: 33330| 725k|const JanetSpecial *janetc_special(const uint8_t *name) { 33331| 725k| return janet_strbinsearch( 33332| 725k| &janetc_specials, 33333| 725k| sizeof(janetc_specials) / sizeof(JanetSpecial), 33334| 725k| sizeof(JanetSpecial), 33335| 725k| name); 33336| 725k|} janet_string: 33466| 3.40M|const uint8_t *janet_string(const uint8_t *buf, int32_t len) { 33467| 3.40M| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1); 33468| 3.40M| head->length = len; 33469| 3.40M| head->hash = janet_string_calchash(buf, len); 33470| 3.40M| uint8_t *data = (uint8_t *)head->data; 33471| 3.40M| safe_memcpy(data, buf, len); 33472| 3.40M| data[len] = 0; 33473| 3.40M| return data; 33474| 3.40M|} janet_string_compare: 33477| 1.10M|int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) { 33478| 1.10M| int32_t xlen = janet_string_length(lhs); ------------------ | | 1813| 1.10M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 1.10M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33479| 1.10M| int32_t ylen = janet_string_length(rhs); ------------------ | | 1813| 1.10M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 1.10M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33480| 1.10M| int32_t len = xlen > ylen ? ylen : xlen; ------------------ | Branch (33480:19): [True: 243, False: 1.10M] ------------------ 33481| 1.10M| int res = memcmp(lhs, rhs, len); 33482| 1.10M| if (res) return res > 0 ? 1 : -1; ------------------ | Branch (33482:9): [True: 1.04k, False: 1.10M] | Branch (33482:21): [True: 92, False: 954] ------------------ 33483| 1.10M| if (xlen == ylen) return 0; ------------------ | Branch (33483:9): [True: 1.10M, False: 105] ------------------ 33484| 105| return xlen < ylen ? -1 : 1; ------------------ | Branch (33484:12): [True: 58, False: 47] ------------------ 33485| 1.10M|} janet_string_equalconst: 33488| 41.2M|int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) { 33489| 41.2M| int32_t lhash = janet_string_hash(lhs); ------------------ | | 1814| 41.2M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 41.2M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33490| 41.2M| int32_t llen = janet_string_length(lhs); ------------------ | | 1813| 41.2M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 41.2M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33491| 41.2M| if (lhash != rhash || llen != rlen) ------------------ | Branch (33491:9): [True: 8.45M, False: 32.8M] | Branch (33491:27): [True: 0, False: 32.8M] ------------------ 33492| 8.45M| return 0; 33493| 32.8M| if (lhs == rhs) ------------------ | Branch (33493:9): [True: 2.10M, False: 30.7M] ------------------ 33494| 2.10M| return 1; 33495| 30.7M| return !memcmp(lhs, rhs, rlen); 33496| 32.8M|} janet_string_equal: 33499| 1.43M|int janet_string_equal(const uint8_t *lhs, const uint8_t *rhs) { 33500| 1.43M| return janet_string_equalconst(lhs, rhs, 33501| 1.43M| janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1813| 1.43M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 1.43M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ janet_string_length(rhs), janet_string_hash(rhs)); ------------------ | | 1814| 1.43M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 1.43M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 33502| 1.43M|} janet_cstring: 33505| 1.22M|const uint8_t *janet_cstring(const char *str) { 33506| 1.22M| return janet_string((const uint8_t *)str, (int32_t)strlen(str)); 33507| 1.22M|} cfun_string_slice: 33604| 435| "an error is raised.") { 33605| 435| JanetByteView view = janet_getbytes(argv, 0); 33606| 435| JanetRange range = janet_getslice(argc, argv); 33607| 435| return janet_stringv(view.bytes + range.start, range.end - range.start); ------------------ | | 1827| 435|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 435|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 435| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 435|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 435|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33608| 435|} cfun_string_hasprefix: 33752| 336k| "Tests whether `str` starts with `pfx`.") { 33753| 336k| janet_fixarity(argc, 2); 33754| 336k| JanetByteView prefix = janet_getbytes(argv, 0); 33755| 336k| JanetByteView str = janet_getbytes(argv, 1); 33756| 336k| return str.len < prefix.len ------------------ | Branch (33756:12): [True: 0, False: 336k] ------------------ 33757| 336k| ? janet_wrap_false() ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33758| 336k| : janet_wrap_boolean(memcmp(prefix.bytes, str.bytes, prefix.len) == 0); ------------------ | | 834| 336k|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 336k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 336k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 336k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33759| 336k|} cfun_string_format: 33997| 6| "* `n`, `N` - pretty format on one line without truncation") { 33998| 6| janet_arity(argc, 1, -1); 33999| 6| JanetBuffer *buffer = janet_buffer(0); 34000| 6| const char *strfrmt = (const char *) janet_getstring(argv, 0); 34001| 6| janet_buffer_format(buffer, strfrmt, 0, argc, argv); 34002| 6| return janet_stringv(buffer->data, buffer->count); ------------------ | | 1827| 6|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 6|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 6| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 6|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 6|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34003| 6|} janet_lib_string: 34074| 264|void janet_lib_string(JanetTable *env) { 34075| 264| JanetRegExt string_cfuns[] = { 34076| 264| JANET_CORE_REG("string/slice", cfun_string_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34077| 264| JANET_CORE_REG("keyword/slice", cfun_keyword_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34078| 264| JANET_CORE_REG("symbol/slice", cfun_symbol_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34079| 264| JANET_CORE_REG("string/repeat", cfun_string_repeat), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34080| 264| JANET_CORE_REG("string/bytes", cfun_string_bytes), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34081| 264| JANET_CORE_REG("string/from-bytes", cfun_string_frombytes), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34082| 264| JANET_CORE_REG("string/ascii-lower", cfun_string_asciilower), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34083| 264| JANET_CORE_REG("string/ascii-upper", cfun_string_asciiupper), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34084| 264| JANET_CORE_REG("string/reverse", cfun_string_reverse), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34085| 264| JANET_CORE_REG("string/find", cfun_string_find), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34086| 264| JANET_CORE_REG("string/find-all", cfun_string_findall), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34087| 264| JANET_CORE_REG("string/has-prefix?", cfun_string_hasprefix), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34088| 264| JANET_CORE_REG("string/has-suffix?", cfun_string_hassuffix), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34089| 264| JANET_CORE_REG("string/replace", cfun_string_replace), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34090| 264| JANET_CORE_REG("string/replace-all", cfun_string_replaceall), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34091| 264| JANET_CORE_REG("string/split", cfun_string_split), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34092| 264| JANET_CORE_REG("string/check-set", cfun_string_checkset), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34093| 264| JANET_CORE_REG("string/join", cfun_string_join), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34094| 264| JANET_CORE_REG("string/format", cfun_string_format), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34095| 264| JANET_CORE_REG("string/trim", cfun_string_trim), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34096| 264| JANET_CORE_REG("string/triml", cfun_string_triml), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34097| 264| JANET_CORE_REG("string/trimr", cfun_string_trimr), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34098| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 34099| 264| }; 34100| | janet_core_cfuns_ext(env, NULL, string_cfuns); 34101| 264|} janet_scan_number_base: 34362| 1.52M| double *out) { 34363| 1.52M| const uint8_t *end = str + len; 34364| 1.52M| int seenadigit = 0; 34365| 1.52M| int ex = 0; 34366| 1.52M| int seenpoint = 0; 34367| 1.52M| int foundexp = 0; 34368| 1.52M| int neg = 0; 34369| 1.52M| struct BigNat mant; 34370| 1.52M| bignat_zero(&mant); 34371| | 34372| | /* Prevent some kinds of overflow bugs relating to the exponent 34373| | * overflowing. For example, if a string was passed 2GB worth of 0s after 34374| | * the decimal point, exponent could wrap around and become positive. It's 34375| | * easier to reject ridiculously large inputs than to check for overflows. 34376| | * */ 34377| 1.52M| if (len > JANET_NUMBER_LENGTH_RIDICULOUS) goto error; ------------------ | |34158| 1.52M|#define JANET_NUMBER_LENGTH_RIDICULOUS 0xFFFF ------------------ | Branch (34377:9): [True: 211, False: 1.52M] ------------------ 34378| | 34379| | /* Get sign */ 34380| 1.52M| if (str >= end) goto error; ------------------ | Branch (34380:9): [True: 0, False: 1.52M] ------------------ 34381| 1.52M| if (*str == '-') { ------------------ | Branch (34381:9): [True: 493k, False: 1.03M] ------------------ 34382| 493k| neg = 1; 34383| 493k| str++; 34384| 1.03M| } else if (*str == '+') { ------------------ | Branch (34384:16): [True: 144k, False: 888k] ------------------ 34385| 144k| str++; 34386| 144k| } 34387| | 34388| | /* Check for leading 0x or digit digit r */ 34389| 1.52M| if (base == 0) { ------------------ | Branch (34389:9): [True: 1.52M, False: 0] ------------------ 34390| 1.52M| if (str + 1 < end && str[0] == '0' && str[1] == 'x') { ------------------ | Branch (34390:13): [True: 131k, False: 1.39M] | Branch (34390:30): [True: 5.92k, False: 125k] | Branch (34390:47): [True: 0, False: 5.92k] ------------------ 34391| 0| base = 16; 34392| 0| str += 2; 34393| 1.52M| } else if (str + 1 < end && ------------------ | Branch (34393:20): [True: 131k, False: 1.39M] ------------------ 34394| 131k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34394:20): [True: 30.3k, False: 101k] | Branch (34394:37): [True: 27.5k, False: 2.73k] ------------------ 34395| 27.5k| str[1] == 'r') { ------------------ | Branch (34395:20): [True: 0, False: 27.5k] ------------------ 34396| 0| base = str[0] - '0'; 34397| 0| str += 2; 34398| 1.52M| } else if (str + 2 < end && ------------------ | Branch (34398:20): [True: 29.2k, False: 1.49M] ------------------ 34399| 29.2k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34399:20): [True: 26.3k, False: 2.87k] | Branch (34399:37): [True: 25.8k, False: 482] ------------------ 34400| 25.8k| str[1] >= '0' && str[1] <= '9' && ------------------ | Branch (34400:20): [True: 21.9k, False: 3.88k] | Branch (34400:37): [True: 21.8k, False: 88] ------------------ 34401| 21.8k| str[2] == 'r') { ------------------ | Branch (34401:20): [True: 173, False: 21.7k] ------------------ 34402| 173| base = 10 * (str[0] - '0') + (str[1] - '0'); 34403| 173| if (base < 2 || base > 36) goto error; ------------------ | Branch (34403:17): [True: 2, False: 171] | Branch (34403:29): [True: 0, False: 171] ------------------ 34404| 171| str += 3; 34405| 171| } 34406| 1.52M| } 34407| | 34408| | /* If still base is 0, set to default (10) */ 34409| 1.52M| if (base == 0) { ------------------ | Branch (34409:9): [True: 1.52M, False: 171] ------------------ 34410| 1.52M| base = 10; 34411| 1.52M| } 34412| 1.52M| int exp_base = base; 34413| | 34414| | /* Skip leading zeros */ 34415| 1.88M| while (str < end && (*str == '0' || *str == '.')) { ------------------ | Branch (34415:12): [True: 1.01M, False: 875k] | Branch (34415:26): [True: 175k, False: 835k] | Branch (34415:41): [True: 184k, False: 650k] ------------------ 34416| 360k| if (seenpoint) ex--; ------------------ | Branch (34416:13): [True: 98.1k, False: 262k] ------------------ 34417| 360k| if (*str == '.') { ------------------ | Branch (34417:13): [True: 184k, False: 175k] ------------------ 34418| 184k| if (seenpoint) goto error; ------------------ | Branch (34418:17): [True: 636, False: 183k] ------------------ 34419| 183k| seenpoint = 1; 34420| 183k| } else { 34421| 175k| seenadigit = 1; 34422| 175k| } 34423| 359k| str++; 34424| 359k| } 34425| | 34426| | /* Parse significant digits */ 34427| 2.32M| while (str < end) { ------------------ | Branch (34427:12): [True: 815k, False: 1.50M] ------------------ 34428| 815k| if (*str == '.') { ------------------ | Branch (34428:13): [True: 84, False: 815k] ------------------ 34429| 84| if (seenpoint) goto error; ------------------ | Branch (34429:17): [True: 57, False: 27] ------------------ 34430| 27| seenpoint = 1; 34431| 815k| } else if (*str == '&') { ------------------ | Branch (34431:20): [True: 6.19k, False: 808k] ------------------ 34432| 6.19k| foundexp = 1; 34433| 6.19k| break; 34434| 808k| } else if (base == 16 && (*str == 'P' || *str == 'p')) { /* IEEE hex float */ ------------------ | Branch (34434:20): [True: 0, False: 808k] | Branch (34434:35): [True: 0, False: 0] | Branch (34434:50): [True: 0, False: 0] ------------------ 34435| 0| foundexp = 1; 34436| 0| exp_base = 10; 34437| 0| base = 2; 34438| 0| ex *= 4; /* We need to correct the current exponent after we change the base */ 34439| 0| break; 34440| 808k| } else if (base == 10 && (*str == 'E' || *str == 'e')) { ------------------ | Branch (34440:20): [True: 803k, False: 5.06k] | Branch (34440:35): [True: 664, False: 803k] | Branch (34440:50): [True: 67, False: 803k] ------------------ 34441| 731| foundexp = 1; 34442| 731| break; 34443| 808k| } else if (*str == '_') { ------------------ | Branch (34443:20): [True: 1.84k, False: 806k] ------------------ 34444| 1.84k| if (!seenadigit) goto error; ------------------ | Branch (34444:17): [True: 1.27k, False: 573] ------------------ 34445| 806k| } else { 34446| 806k| int digit = digit_lookup[*str & 0x7F]; 34447| 806k| if (*str > 127 || digit >= base) goto error; ------------------ | Branch (34447:17): [True: 212, False: 806k] | Branch (34447:31): [True: 11.2k, False: 794k] ------------------ 34448| 794k| if (seenpoint) ex--; ------------------ | Branch (34448:17): [True: 43.7k, False: 751k] ------------------ 34449| 794k| bignat_muladd(&mant, base, digit); 34450| 794k| seenadigit = 1; 34451| 794k| } 34452| 795k| str++; 34453| 795k| } 34454| | 34455| 1.51M| if (!seenadigit) ------------------ | Branch (34455:9): [True: 708k, False: 805k] ------------------ 34456| 708k| goto error; 34457| | 34458| | /* Read exponent */ 34459| 805k| if (str < end && foundexp) { ------------------ | Branch (34459:9): [True: 5.60k, False: 799k] | Branch (34459:22): [True: 5.60k, False: 0] ------------------ 34460| 5.60k| int eneg = 0; 34461| 5.60k| int32_t ee = 0; 34462| 5.60k| seenadigit = 0; 34463| 5.60k| str++; 34464| 5.60k| if (str >= end) goto error; ------------------ | Branch (34464:13): [True: 5, False: 5.59k] ------------------ 34465| 5.59k| if (*str == '-') { ------------------ | Branch (34465:13): [True: 0, False: 5.59k] ------------------ 34466| 0| eneg = 1; 34467| 0| str++; 34468| 5.59k| } else if (*str == '+') { ------------------ | Branch (34468:20): [True: 0, False: 5.59k] ------------------ 34469| 0| str++; 34470| 0| } 34471| | /* Skip leading 0s in exponent */ 34472| 9.11k| while (str < end && *str == '0') { ------------------ | Branch (34472:16): [True: 5.59k, False: 3.51k] | Branch (34472:29): [True: 3.51k, False: 2.08k] ------------------ 34473| 3.51k| str++; 34474| 3.51k| seenadigit = 1; 34475| 3.51k| } 34476| 10.3k| while (str < end) { ------------------ | Branch (34476:16): [True: 4.73k, False: 5.58k] ------------------ 34477| 4.73k| int digit = digit_lookup[*str & 0x7F]; 34478| 4.73k| if (*str > 127 || digit >= exp_base) goto error; ------------------ | Branch (34478:17): [True: 0, False: 4.73k] | Branch (34478:31): [True: 9, False: 4.72k] ------------------ 34479| 4.72k| if (ee < (INT32_MAX / 40)) { ------------------ | Branch (34479:17): [True: 4.30k, False: 419] ------------------ 34480| 4.30k| ee = exp_base * ee + digit; 34481| 4.30k| } 34482| 4.72k| str++; 34483| 4.72k| seenadigit = 1; 34484| 4.72k| } 34485| 5.58k| if (eneg) ex -= ee; ------------------ | Branch (34485:13): [True: 0, False: 5.58k] ------------------ 34486| 5.58k| else ex += ee; 34487| 5.58k| } 34488| | 34489| 805k| if (!seenadigit) ------------------ | Branch (34489:9): [True: 0, False: 805k] ------------------ 34490| 0| goto error; 34491| | 34492| 805k| *out = convert(neg, &mant, base, ex); 34493| 805k| janet_free(mant.digits); ------------------ | | 2415| 805k|#define janet_free(X) free((X)) ------------------ 34494| 805k| return 0; 34495| | 34496| 721k|error: 34497| 721k| janet_free(mant.digits); ------------------ | | 2415| 721k|#define janet_free(X) free((X)) ------------------ 34498| 721k| return 1; 34499| 805k|} janet_scan_int64: 34572| 5.76k|int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) { 34573| 5.76k| int neg; 34574| 5.76k| uint64_t bi; 34575| 5.76k| if (scan_uint64(str, len, &bi, &neg)) { ------------------ | Branch (34575:9): [True: 4.67k, False: 1.08k] ------------------ 34576| 4.67k| if (neg && bi <= ((UINT64_MAX / 2) + 1)) { ------------------ | Branch (34576:13): [True: 287, False: 4.38k] | Branch (34576:20): [True: 287, False: 0] ------------------ 34577| 287| if (bi > INT64_MAX) { ------------------ | Branch (34577:17): [True: 0, False: 287] ------------------ 34578| 0| *out = INT64_MIN; 34579| 287| } else { 34580| 287| *out = -((int64_t) bi); 34581| 287| } 34582| 287| return 1; 34583| 287| } 34584| 4.38k| if (!neg && bi <= INT64_MAX) { ------------------ | Branch (34584:13): [True: 4.38k, False: 0] | Branch (34584:21): [True: 4.38k, False: 1] ------------------ 34585| 4.38k| *out = (int64_t) bi; 34586| 4.38k| return 1; 34587| 4.38k| } 34588| 4.38k| } 34589| 1.08k| return 0; 34590| 5.76k|} janet_scan_uint64: 34592| 356|int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out) { 34593| 356| int neg; 34594| 356| uint64_t bi; 34595| 356| if (scan_uint64(str, len, &bi, &neg)) { ------------------ | Branch (34595:9): [True: 206, False: 150] ------------------ 34596| 206| if (!neg) { ------------------ | Branch (34596:13): [True: 206, False: 0] ------------------ 34597| 206| *out = bi; 34598| 206| return 1; 34599| 206| } 34600| 206| } 34601| 150| return 0; 34602| 356|} janet_scan_numeric: 34609| 1.53M| Janet *out) { 34610| 1.53M| int result; 34611| 1.53M| double num; 34612| 1.53M| int64_t i64 = 0; 34613| 1.53M| uint64_t u64 = 0; 34614| 1.53M| if (len < 2 || str[len - 2] != ':') { ------------------ | Branch (34614:9): [True: 1.38M, False: 145k] | Branch (34614:20): [True: 139k, False: 6.21k] ------------------ 34615| 1.52M| result = janet_scan_number_base(str, len, 0, &num); 34616| 1.52M| *out = janet_wrap_number(num); ------------------ | | 835| 1.52M|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 34617| 1.52M| return result; 34618| 1.52M| } 34619| 6.21k| switch (str[len - 1]) { 34620| 101| default: ------------------ | Branch (34620:9): [True: 101, False: 6.11k] ------------------ 34621| 101| return 1; 34622| 0| case 'n': ------------------ | Branch (34622:9): [True: 0, False: 6.21k] ------------------ 34623| 0| result = janet_scan_number_base(str, len - 2, 0, &num); 34624| 0| *out = janet_wrap_number(num); ------------------ | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 34625| 0| return result; 34626| | /* Condition is inverted janet_scan_int64 and janet_scan_uint64 */ 34627| 5.76k| case 's': ------------------ | Branch (34627:9): [True: 5.76k, False: 457] ------------------ 34628| 5.76k| result = !janet_scan_int64(str, len - 2, &i64); 34629| 5.76k| *out = janet_wrap_s64(i64); 34630| 5.76k| return result; 34631| 356| case 'u': ------------------ | Branch (34631:9): [True: 356, False: 5.86k] ------------------ 34632| 356| result = !janet_scan_uint64(str, len - 2, &u64); 34633| 356| *out = janet_wrap_u64(u64); 34634| 356| return result; 34635| 6.21k| } 34636| 6.21k|} janet_buffer_dtostr: 34640| 49.0k|void janet_buffer_dtostr(JanetBuffer *buffer, double x) { 34641| 49.0k|#define BUFSIZE 32 34642| 49.0k| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |34641| 49.0k|#define BUFSIZE 32 ------------------ 34643| 49.0k| int count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, "%.17g", x); ------------------ | |34641| 49.0k|#define BUFSIZE 32 ------------------ 34644| 49.0k|#undef BUFSIZE 34645| | /* fix locale issues with commas */ 34646| 101k| for (int i = 0; i < count; i++) { ------------------ | Branch (34646:21): [True: 52.7k, False: 49.0k] ------------------ 34647| 52.7k| char c = buffer->data[buffer->count + i]; 34648| 52.7k| if (c == ',') { ------------------ | Branch (34648:13): [True: 0, False: 52.7k] ------------------ 34649| 0| buffer->data[buffer->count + i] = '.'; 34650| 0| } 34651| 52.7k| } 34652| 49.0k| buffer->count += count; 34653| 49.0k|} janet_struct_begin: 34690| 1.54M|JanetKV *janet_struct_begin(int32_t count) { 34691| | /* Calculate capacity as power of 2 after 2 * count. */ 34692| 1.54M| int32_t capacity = janet_tablen(2 * count); 34693| 1.54M| if (capacity < 0) capacity = janet_tablen(count + 1); ------------------ | Branch (34693:9): [True: 0, False: 1.54M] ------------------ 34694| | 34695| 1.54M| size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV); 34696| 1.54M| JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size); 34697| 1.54M| head->length = count; 34698| 1.54M| head->capacity = capacity; 34699| 1.54M| head->hash = 0; 34700| 1.54M| head->proto = NULL; 34701| | 34702| 1.54M| JanetKV *st = (JanetKV *)(head->data); 34703| 1.54M| janet_memempty(st, capacity); 34704| 1.54M| return st; 34705| 1.54M|} janet_struct_find: 34708| 2.17M|const JanetKV *janet_struct_find(const JanetKV *st, Janet key) { 34709| | return janet_dict_find(st, janet_struct_capacity(st), key); ------------------ | | 1849| 2.17M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 2.17M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34710| 2.17M|} janet_struct_put_ext: 34720| 17.5M|void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) { 34721| 17.5M| int32_t cap = janet_struct_capacity(st); ------------------ | | 1849| 17.5M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 17.5M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34722| 17.5M| int32_t hash = janet_hash(key); 34723| 17.5M| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 17.5M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34724| 17.5M| int32_t i, j, dist; 34725| 17.5M| int32_t bounds[4] = {index, cap, 0, index}; 34726| 17.5M| if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 35.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 768, False: 17.5M] | | | Branch (806:6): [Folded, False: 17.5M] | | ------------------ | | 807| 35.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 35.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 17.5M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 17.5M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 17.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 17.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return; ------------------ | | 806| 17.5M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 7, False: 17.5M] | | | Branch (806:6): [Folded, False: 17.5M] | | ------------------ | | 807| 17.5M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 17.5M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 17.5M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 17.5M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 17.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 17.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34727| 17.5M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 35.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 52, False: 17.5M] | | | Branch (806:6): [True: 17.5M, Folded] | | ------------------ | | 807| 35.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 17.5M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 52, False: 17.5M] | | | | | Branch (803:28): [True: 0, False: 17.5M] | | | | ------------------ | | ------------------ | | 808| 35.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34727:47): [True: 0, False: 52] ------------------ 34728| | /* Avoid extra items */ 34729| 17.5M| if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1850| 17.5M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 17.5M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) == janet_struct_length(st)) return; ------------------ | | 1848| 17.5M|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 17.5M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34729:9): [True: 0, False: 17.5M] ------------------ 34730| 17.5M| for (dist = 0, j = 0; j < 4; j += 2) ------------------ | Branch (34730:27): [True: 17.5M, False: 0] ------------------ 34731| 19.0M| for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) { ------------------ | Branch (34731:29): [True: 19.0M, False: 25] ------------------ 34732| 19.0M| int status; 34733| 19.0M| int32_t otherhash; 34734| 19.0M| int32_t otherindex, otherdist; 34735| 19.0M| JanetKV *kv = st + i; 34736| | /* We found an empty slot, so just add key and value */ 34737| 19.0M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 19.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 16.9M, False: 2.14M] | | | Branch (806:6): [Folded, False: 19.0M] | | ------------------ | | 807| 19.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 19.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 19.0M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 19.0M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 19.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34738| 16.9M| kv->key = key; 34739| 16.9M| kv->value = value; 34740| | /* Update the temporary count */ 34741| 16.9M| janet_struct_hash(st)++; ------------------ | | 1850| 16.9M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 16.9M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34742| 16.9M| return; 34743| 16.9M| } 34744| | /* Robinhood hashing - check if colliding kv pair 34745| | * is closer to their source than current. We use robinhood 34746| | * hashing to ensure that equivalent structs that are constructed 34747| | * with different order have the same internal layout, and therefor 34748| | * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}. 34749| | * Collisions are resolved via an insertion sort insertion. */ 34750| 2.14M| otherhash = janet_hash(kv->key); 34751| 2.14M| otherindex = janet_maphash(cap, otherhash); ------------------ | | 396| 2.14M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 34752| 2.14M| otherdist = (i + cap - otherindex) & (cap - 1); 34753| 2.14M| if (dist < otherdist) ------------------ | Branch (34753:17): [True: 3.02k, False: 2.13M] ------------------ 34754| 3.02k| status = -1; 34755| 2.13M| else if (otherdist < dist) ------------------ | Branch (34755:22): [True: 82, False: 2.13M] ------------------ 34756| 82| status = 1; 34757| 2.13M| else if (hash < otherhash) ------------------ | Branch (34757:22): [True: 1.54M, False: 595k] ------------------ 34758| 1.54M| status = -1; 34759| 595k| else if (otherhash < hash) ------------------ | Branch (34759:22): [True: 202, False: 595k] ------------------ 34760| 202| status = 1; 34761| 595k| else 34762| 595k| status = janet_compare(key, kv->key); 34763| | /* If other is closer to their ideal slot */ 34764| 2.14M| if (status == 1) { ------------------ | Branch (34764:17): [True: 284, False: 2.14M] ------------------ 34765| | /* Swap current kv pair with pair in slot */ 34766| 284| JanetKV temp = *kv; 34767| 284| kv->key = key; 34768| 284| kv->value = value; 34769| 284| key = temp.key; 34770| 284| value = temp.value; 34771| | /* Save dist and hash of new kv pair */ 34772| 284| dist = otherdist; 34773| 284| hash = otherhash; 34774| 2.14M| } else if (status == 0) { ------------------ | Branch (34774:24): [True: 593k, False: 1.54M] ------------------ 34775| 593k| if (replace) { ------------------ | Branch (34775:21): [True: 593k, False: 0] ------------------ 34776| | /* A key was added to the struct more than once - replace old value */ 34777| 593k| kv->value = value; 34778| 593k| } 34779| 593k| return; 34780| 593k| } 34781| 2.14M| } 34782| 17.5M|} janet_struct_put: 34784| 17.5M|void janet_struct_put(JanetKV *st, Janet key, Janet value) { 34785| 17.5M| janet_struct_put_ext(st, key, value, 1); 34786| 17.5M|} janet_struct_end: 34789| 1.54M|const JanetKV *janet_struct_end(JanetKV *st) { 34790| 1.54M| if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1850| 1.54M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 1.54M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(st) != janet_struct_length(st)) { ------------------ | | 1848| 1.54M|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 1.54M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34790:9): [True: 66, False: 1.54M] ------------------ 34791| | /* Error building struct, probably duplicate values. We need to rebuild 34792| | * the struct using only the values that went in. The second creation should always 34793| | * succeed. */ 34794| 66| JanetKV *newst = janet_struct_begin(janet_struct_hash(st)); ------------------ | | 1850| 66|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 66|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34795| 1.71M| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1849| 1.71M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 1.71M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34795:29): [True: 1.71M, False: 66] ------------------ 34796| 1.71M| JanetKV *kv = st + i; 34797| 1.71M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 1.71M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 1.71M] | | ------------------ | | 807| 1.71M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.71M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.71M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.71M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.71M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.71M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34797:17): [True: 2.07k, False: 1.71M] ------------------ 34798| 2.07k| janet_struct_put(newst, kv->key, kv->value); 34799| 2.07k| } 34800| 1.71M| } 34801| 66| janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1851| 66|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 66|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(newst) = janet_struct_proto(st); ------------------ | | 1851| 66|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 66|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34802| 66| st = newst; 34803| 66| } 34804| 1.54M| janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1850| 1.54M|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 1.54M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st)); ------------------ | | 1849| 1.54M|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 1.54M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34805| 1.54M| if (janet_struct_proto(st)) { ------------------ | | 1851| 1.54M|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 1.54M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 1.54M] | | ------------------ ------------------ 34806| 0| janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1850| 0|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st)); ------------------ | | 1850| 0|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 34807| 0| } 34808| 1.54M| return (const JanetKV *)st; 34809| 1.54M|} janet_struct_rawget: 34812| 3.09k|Janet janet_struct_rawget(const JanetKV *st, Janet key) { 34813| 3.09k| const JanetKV *kv = janet_struct_find(st, key); 34814| 3.09k| return kv ? kv->value : janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34814:12): [True: 3.09k, False: 0] ------------------ 34815| 3.09k|} janet_struct_get: 34818| 2.17M|Janet janet_struct_get(const JanetKV *st, Janet key) { 34819| 3.96M| for (int i = JANET_MAX_PROTO_DEPTH; st && i; --i, st = janet_struct_proto(st)) { ------------------ | | 299| 2.17M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ for (int i = JANET_MAX_PROTO_DEPTH; st && i; --i, st = janet_struct_proto(st)) { ------------------ | | 1851| 1.78M|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 1.78M|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (34819:41): [True: 2.17M, False: 1.78M] | Branch (34819:47): [True: 2.17M, False: 0] ------------------ 34820| 2.17M| const JanetKV *kv = janet_struct_find(st, key); 34821| 2.17M| if (NULL != kv && !janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 2.17M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.17M] | | ------------------ | | 807| 2.17M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.17M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.17M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.17M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.17M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.17M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (34821:13): [True: 2.17M, False: 0] | Branch (34821:27): [True: 388k, False: 1.78M] ------------------ 34822| 388k| return kv->value; 34823| 388k| } 34824| 2.17M| } 34825| 1.78M| return janet_wrap_nil(); ------------------ | | 831| 1.78M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.78M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.78M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.78M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 34826| 2.17M|} cfun_struct_rawget: 34949| 3.09k| "nil without checking the prototype. Returns the value in the struct.") { 34950| 3.09k| janet_fixarity(argc, 2); 34951| 3.09k| JanetStruct st = janet_getstruct(argv, 0); 34952| 3.09k| return janet_struct_rawget(st, argv[1]); 34953| 3.09k|} janet_lib_struct: 34956| 264|void janet_lib_struct(JanetTable *env) { 34957| 264| JanetRegExt struct_cfuns[] = { 34958| 264| JANET_CORE_REG("struct/with-proto", cfun_struct_with_proto), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34959| 264| JANET_CORE_REG("struct/getproto", cfun_struct_getproto), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34960| 264| JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34961| 264| JANET_CORE_REG("struct/to-table", cfun_struct_to_table), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34962| 264| JANET_CORE_REG("struct/rawget", cfun_struct_rawget), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 34963| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 34964| 264| }; 34965| | janet_core_cfuns_ext(env, NULL, struct_cfuns); 34966| 264|} janet_symcache_init: 35011| 264|void janet_symcache_init() { 35012| 264| janet_vm.cache_capacity = 1024; 35013| 264| janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *)); ------------------ | | 2412| 264|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 35014| 264| if (NULL == janet_vm.cache) { ------------------ | Branch (35014:9): [True: 0, False: 264] ------------------ 35015| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35016| 0| } 35017| 264| memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter)); 35018| 264| janet_vm.gensym_counter[0] = '_'; 35019| 264| janet_vm.cache_count = 0; 35020| 264| janet_vm.cache_deleted = 0; 35021| 264|} janet_symcache_deinit: 35024| 264|void janet_symcache_deinit() { 35025| 264| janet_free((void *)janet_vm.cache); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 35026| | janet_vm.cache = NULL; 35027| 264| janet_vm.cache_capacity = 0; 35028| 264| janet_vm.cache_count = 0; 35029| 264| janet_vm.cache_deleted = 0; 35030| 264|} janet_symbol_deinit: 35132| 1.13M|void janet_symbol_deinit(const uint8_t *sym) { 35133| 1.13M| int status = 0; 35134| 1.13M| const uint8_t **bucket = janet_symcache_find(sym, &status); ------------------ | |35087| 1.13M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 1.13M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 1.13M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1814| 1.13M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 1.13M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35135| 1.13M| if (status) { ------------------ | Branch (35135:9): [True: 1.13M, False: 0] ------------------ 35136| 1.13M| janet_vm.cache_count--; 35137| 1.13M| janet_vm.cache_deleted++; 35138| 1.13M| *bucket = JANET_SYMCACHE_DELETED; 35139| 1.13M| } 35140| 1.13M|} janet_symbol: 35143| 24.7M|const uint8_t *janet_symbol(const uint8_t *str, int32_t len) { 35144| 24.7M| int32_t hash = janet_string_calchash(str, len); 35145| 24.7M| uint8_t *newstr; 35146| 24.7M| int success = 0; 35147| 24.7M| const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success); 35148| 24.7M| if (success) ------------------ | Branch (35148:9): [True: 24.1M, False: 531k] ------------------ 35149| 24.1M| return *bucket; 35150| 531k| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1); 35151| 531k| head->hash = hash; 35152| 531k| head->length = len; 35153| 531k| newstr = (uint8_t *)(head->data); 35154| 531k| safe_memcpy(newstr, str, len); 35155| 531k| newstr[len] = 0; 35156| 531k| janet_symcache_put((const uint8_t *)newstr, bucket); 35157| 531k| return newstr; 35158| 24.7M|} janet_csymbol: 35161| 22.2M|const uint8_t *janet_csymbol(const char *cstr) { 35162| 22.2M| return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr)); 35163| 22.2M|} janet_symbol_gen: 35186| 598k|const uint8_t *janet_symbol_gen(void) { 35187| 598k| const uint8_t **bucket = NULL; 35188| 598k| uint8_t *sym; 35189| 598k| int32_t hash = 0; 35190| 598k| int status; 35191| | /* Leave spaces for 6 base 64 digits and two dashes. That means 64^6 possible suffixes, which 35192| | * is enough for resolving collisions. */ 35193| 1.24M| do { 35194| 1.24M| hash = janet_string_calchash( 35195| 1.24M| janet_vm.gensym_counter, 35196| 1.24M| sizeof(janet_vm.gensym_counter) - 1); 35197| 1.24M| bucket = janet_symcache_findmem( 35198| 1.24M| janet_vm.gensym_counter, 35199| 1.24M| sizeof(janet_vm.gensym_counter) - 1, 35200| 1.24M| hash, 35201| 1.24M| &status); 35202| 1.24M| } while (status && (inc_gensym(), 1)); ------------------ | Branch (35202:14): [True: 645k, False: 598k] | Branch (35202:24): [True: 645k, False: 0] ------------------ 35203| 598k| JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + sizeof(janet_vm.gensym_counter)); 35204| 598k| head->length = sizeof(janet_vm.gensym_counter) - 1; 35205| 598k| head->hash = hash; 35206| 598k| sym = (uint8_t *)(head->data); 35207| 598k| memcpy(sym, janet_vm.gensym_counter, sizeof(janet_vm.gensym_counter)); 35208| 598k| sym[head->length] = 0; 35209| 598k| janet_symcache_put((const uint8_t *)sym, bucket); 35210| 598k| return (const uint8_t *)sym; 35211| 598k|} janet_table_init: 35287| 54.2k|JanetTable *janet_table_init(JanetTable *table, int32_t capacity) { 35288| 54.2k| return janet_table_init_impl(table, capacity, 1); 35289| 54.2k|} janet_table_init_raw: 35292| 792|JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) { 35293| 792| return janet_table_init_impl(table, capacity, 0); 35294| 792|} janet_table_deinit: 35297| 55.0k|void janet_table_deinit(JanetTable *table) { 35298| 55.0k| if (table->gc.flags & JANET_TABLE_FLAG_STACK) { ------------------ | |35247| 55.0k|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (35298:9): [True: 54.2k, False: 792] ------------------ 35299| 54.2k| janet_sfree(table->data); 35300| 54.2k| } else { 35301| 792| janet_free(table->data); ------------------ | | 2415| 792|#define janet_free(X) free((X)) ------------------ 35302| 792| } 35303| 55.0k|} janet_table: 35307| 297k|JanetTable *janet_table(int32_t capacity) { 35308| 297k| JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 35309| 297k| return janet_table_init_impl(table, capacity, 0); 35310| 297k|} janet_table_find: 35329| 6.32M|JanetKV *janet_table_find(JanetTable *t, Janet key) { 35330| 6.32M| return (JanetKV *) janet_dict_find(t->data, t->capacity, key); 35331| 6.32M|} janet_table_get: 35365| 2.36M|Janet janet_table_get(JanetTable *t, Janet key) { 35366| 3.23M| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 2.36M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35366:41): [True: 2.36M, False: 871k] | Branch (35366:46): [True: 2.36M, False: 0] ------------------ 35367| 2.36M| JanetKV *bucket = janet_table_find(t, key); 35368| 2.36M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 2.36M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.36M] | | ------------------ | | 807| 2.36M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.36M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.36M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.36M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.36M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.36M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35368:13): [True: 2.36M, False: 0] | Branch (35368:31): [True: 1.49M, False: 871k] ------------------ 35369| 1.49M| return bucket->value; 35370| 2.36M| } 35371| 871k| return janet_wrap_nil(); ------------------ | | 831| 871k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 871k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 871k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 871k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35372| 2.36M|} janet_table_get_keyword: 35375| 2.46M|Janet janet_table_get_keyword(JanetTable *t, const char *keyword) { 35376| 2.46M| int32_t keyword_len = (int32_t) strlen(keyword); 35377| 4.17M| for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) { ------------------ | | 299| 2.46M|#define JANET_MAX_PROTO_DEPTH 200 ------------------ | Branch (35377:41): [True: 2.46M, False: 1.71M] | Branch (35377:46): [True: 2.46M, False: 0] ------------------ 35378| 2.46M| JanetKV *bucket = (JanetKV *) janet_dict_find_keyword(t->data, t->capacity, (const uint8_t *) keyword, keyword_len); 35379| 2.46M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 2.46M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.46M] | | ------------------ | | 807| 2.46M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.46M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.46M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.46M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.46M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.46M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35379:13): [True: 2.46M, False: 0] | Branch (35379:31): [True: 749k, False: 1.71M] ------------------ 35380| 749k| return bucket->value; 35381| 2.46M| } 35382| 1.71M| return janet_wrap_nil(); ------------------ | | 831| 1.71M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.71M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.71M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.71M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35383| 2.46M|} janet_table_rawget: 35398| 938|Janet janet_table_rawget(JanetTable *t, Janet key) { 35399| 938| JanetKV *bucket = janet_table_find(t, key); 35400| 938| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) ------------------ | | 806| 938| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 938] | | ------------------ | | 807| 938| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 938| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 938| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 938|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 938|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 938|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35400:9): [True: 938, False: 0] | Branch (35400:27): [True: 938, False: 0] ------------------ 35401| 938| return bucket->value; 35402| 0| else 35403| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35404| 938|} janet_table_remove: 35408| 343k|Janet janet_table_remove(JanetTable *t, Janet key) { 35409| 343k| JanetKV *bucket = janet_table_find(t, key); 35410| 343k| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 343k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 343k] | | ------------------ | | 807| 343k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 343k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 343k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 343k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 343k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 343k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35410:9): [True: 343k, False: 0] | Branch (35410:27): [True: 158k, False: 185k] ------------------ 35411| 158k| Janet ret = bucket->value; 35412| 158k| t->count--; 35413| 158k| t->deleted++; 35414| 158k| bucket->key = janet_wrap_nil(); ------------------ | | 831| 158k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 158k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 158k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 158k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35415| 158k| bucket->value = janet_wrap_false(); ------------------ | | 833| 158k|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 158k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 158k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 158k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35416| 158k| return ret; 35417| 185k| } else { 35418| 185k| return janet_wrap_nil(); ------------------ | | 831| 185k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 185k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 185k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 185k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35419| 185k| } 35420| 343k|} janet_table_put: 35423| 2.22M|void janet_table_put(JanetTable *t, Janet key, Janet value) { 35424| 2.22M| if (janet_checktype(key, JANET_NIL)) return; ------------------ | | 806| 2.22M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 2.22M] | | | Branch (806:6): [Folded, False: 2.22M] | | ------------------ | | 807| 2.22M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.22M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.22M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.22M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.22M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.22M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35425| 2.22M| if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return; ------------------ | | 806| 4.45M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 902, False: 2.22M] | | | Branch (806:6): [True: 2.22M, Folded] | | ------------------ | | 807| 4.45M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 2.22M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 902, False: 2.22M] | | | | | Branch (803:28): [True: 0, False: 2.22M] | | | | ------------------ | | ------------------ | | 808| 4.45M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35425:47): [True: 0, False: 902] ------------------ 35426| 2.22M| if (janet_checktype(value, JANET_NIL)) { ------------------ | | 806| 2.22M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 137k, False: 2.09M] | | | Branch (806:6): [Folded, False: 2.22M] | | ------------------ | | 807| 2.22M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.22M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.22M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.22M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.22M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.22M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35427| 137k| janet_table_remove(t, key); 35428| 2.09M| } else { 35429| 2.09M| JanetKV *bucket = janet_table_find(t, key); 35430| 2.09M| if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) { ------------------ | | 806| 2.09M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.09M] | | ------------------ | | 807| 2.09M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.09M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.09M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.09M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.09M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.09M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35430:13): [True: 2.09M, False: 0] | Branch (35430:31): [True: 679k, False: 1.41M] ------------------ 35431| 679k| bucket->value = value; 35432| 1.41M| } else { 35433| 1.41M| if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) { ------------------ | Branch (35433:17): [True: 0, False: 1.41M] | Branch (35433:35): [True: 164k, False: 1.24M] ------------------ 35434| 164k| janet_table_rehash(t, janet_tablen(2 * t->count + 2)); 35435| 164k| bucket = janet_table_find(t, key); 35436| 164k| } 35437| 1.41M| if (janet_checktype(bucket->value, JANET_BOOLEAN)) ------------------ | | 806| 1.41M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 1.41M] | | | Branch (806:6): [Folded, False: 1.41M] | | ------------------ | | 807| 1.41M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.41M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.41M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.41M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.41M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.41M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35438| 0| --t->deleted; 35439| 1.41M| bucket->key = key; 35440| 1.41M| bucket->value = value; 35441| 1.41M| ++t->count; 35442| 1.41M| } 35443| 2.09M| } 35444| 2.22M|} janet_table_clone: 35473| 2.34k|JanetTable *janet_table_clone(JanetTable *table) { 35474| 2.34k| JanetTable *newTable = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable)); 35475| 2.34k| newTable->count = table->count; 35476| 2.34k| newTable->capacity = table->capacity; 35477| 2.34k| newTable->deleted = table->deleted; 35478| 2.34k| newTable->proto = table->proto; 35479| 2.34k| newTable->data = array_allocate(sizeof(JanetKV), newTable->capacity); 35480| 2.34k| if (NULL == newTable->data) { ------------------ | Branch (35480:9): [True: 0, False: 2.34k] ------------------ 35481| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35482| 0| } 35483| 2.34k| memcpy(newTable->data, table->data, (size_t) table->capacity * sizeof(JanetKV)); 35484| 2.34k| return newTable; 35485| 2.34k|} janet_table_to_struct: 35509| 669|const JanetKV *janet_table_to_struct(JanetTable *t) { 35510| 669| JanetKV *st = janet_struct_begin(t->count); 35511| 669| JanetKV *kv = t->data; 35512| 669| JanetKV *end = t->data + t->capacity; 35513| 15.8k| while (kv < end) { ------------------ | Branch (35513:12): [True: 15.1k, False: 669] ------------------ 35514| 15.1k| if (!janet_checktype(kv->key, JANET_NIL)) ------------------ | | 806| 15.1k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 15.1k] | | ------------------ | | 807| 15.1k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 15.1k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 15.1k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 15.1k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 15.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 15.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35514:13): [True: 4.88k, False: 10.2k] ------------------ 35515| 4.88k| janet_struct_put(st, kv->key, kv->value); 35516| 15.1k| kv++; 35517| 15.1k| } 35518| 669| return janet_struct_end(st); 35519| 669|} cfun_table_tostruct: 35607| 669| "prototype.") { 35608| 669| janet_arity(argc, 1, 2); 35609| 669| JanetTable *t = janet_gettable(argv, 0); 35610| 669| JanetStruct proto = janet_optstruct(argv, argc, 1, NULL); 35611| 669| JanetStruct st = janet_table_to_struct(t); 35612| 669| janet_struct_proto(st) = proto; ------------------ | | 1851| 669|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 669|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 35613| 669| return janet_wrap_struct(st); ------------------ | | 842| 669|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 669| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 669|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 669|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35614| 669|} cfun_table_rawget: 35620| 938| "nil without checking the prototype. Returns the value in the table.") { 35621| 938| janet_fixarity(argc, 2); 35622| 938| JanetTable *table = janet_gettable(argv, 0); 35623| 938| return janet_table_rawget(table, argv[1]); 35624| 938|} janet_lib_table: 35653| 264|void janet_lib_table(JanetTable *env) { 35654| 264| JanetRegExt table_cfuns[] = { 35655| 264| JANET_CORE_REG("table/new", cfun_table_new), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35656| 264| JANET_CORE_REG("table/weak", cfun_table_weak), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35657| 264| JANET_CORE_REG("table/weak-keys", cfun_table_weak_keys), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35658| 264| JANET_CORE_REG("table/weak-values", cfun_table_weak_values), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35659| 264| JANET_CORE_REG("table/to-struct", cfun_table_tostruct), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35660| 264| JANET_CORE_REG("table/getproto", cfun_table_getproto), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35661| 264| JANET_CORE_REG("table/setproto", cfun_table_setproto), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35662| 264| JANET_CORE_REG("table/rawget", cfun_table_rawget), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35663| 264| JANET_CORE_REG("table/clone", cfun_table_clone), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35664| 264| JANET_CORE_REG("table/clear", cfun_table_clear), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35665| 264| JANET_CORE_REG("table/proto-flatten", cfun_table_proto_flatten), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35666| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 35667| 264| }; 35668| | janet_core_cfuns_ext(env, NULL, table_cfuns); 35669| 264|} janet_tuple_begin: 35708| 11.9M|Janet *janet_tuple_begin(int32_t length) { 35709| 11.9M| size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet)); 35710| 11.9M| JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size); 35711| 11.9M| head->sm_line = -1; 35712| 11.9M| head->sm_column = -1; 35713| 11.9M| head->length = length; 35714| 11.9M| return (Janet *)(head->data); 35715| 11.9M|} janet_tuple_end: 35718| 11.9M|const Janet *janet_tuple_end(Janet *tuple) { 35719| 11.9M| janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1803| 11.9M|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 11.9M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_hash(tuple) = janet_array_calchash(tuple, janet_tuple_length(tuple)); ------------------ | | 1802| 11.9M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 11.9M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 35720| 11.9M| return (const Janet *)tuple; 35721| 11.9M|} janet_tuple_n: 35724| 7.12M|const Janet *janet_tuple_n(const Janet *values, int32_t n) { 35725| 7.12M| Janet *t = janet_tuple_begin(n); 35726| 7.12M| safe_memcpy(t, values, sizeof(Janet) * n); 35727| 7.12M| return janet_tuple_end(t); 35728| 7.12M|} cfun_tuple_brackets: 35734| 239k| "Creates a new bracketed tuple containing the elements xs.") { 35735| 239k| const Janet *tup = janet_tuple_n(argv, argc); 35736| 239k| janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1806| 239k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 239k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1798| 239k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ 35737| 239k| return janet_wrap_tuple(tup); ------------------ | | 843| 239k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 239k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 239k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 239k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35738| 239k|} cfun_tuple_slice: 35754| 2.19M| "raised.") { 35755| 2.19M| JanetView view = janet_getindexed(argv, 0); 35756| 2.19M| JanetRange range = janet_getslice(argc, argv); 35757| 2.19M| return janet_wrap_tuple(janet_tuple_n(view.items + range.start, range.end - range.start)); ------------------ | | 843| 2.19M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 2.19M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.19M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.19M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35758| 2.19M|} cfun_tuple_type: 35766| 2.17M| "the compiler.") { 35767| 2.17M| janet_fixarity(argc, 1); 35768| 2.17M| const Janet *tup = janet_gettuple(argv, 0); 35769| 2.17M| if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { ------------------ | | 1806| 2.17M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 2.17M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) { ------------------ | | 1798| 2.17M|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (35769:9): [True: 239k, False: 1.93M] ------------------ 35770| 239k| return janet_ckeywordv("brackets"); ------------------ | | 1843| 239k|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 239k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 239k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 239k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 239k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35771| 1.93M| } else { 35772| 1.93M| return janet_ckeywordv("parens"); ------------------ | | 1843| 1.93M|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 1.93M|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 1.93M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.93M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.93M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35773| 1.93M| } 35774| 2.17M|} cfun_tuple_sourcemap: 35779| 978k| "which is another tuple `[line column]`.") { 35780| 978k| janet_fixarity(argc, 1); 35781| 978k| const Janet *tup = janet_gettuple(argv, 0); 35782| 978k| Janet contents[2]; 35783| 978k| contents[0] = janet_wrap_integer(janet_tuple_head(tup)->sm_line); ------------------ | | 967| 978k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 978k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 35784| 978k| contents[1] = janet_wrap_integer(janet_tuple_head(tup)->sm_column); ------------------ | | 967| 978k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 978k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 35785| 978k| return janet_wrap_tuple(janet_tuple_n(contents, 2)); ------------------ | | 843| 978k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 978k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 978k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 978k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35786| 978k|} cfun_tuple_setmap: 35791| 978k| "`col` should be integers.") { 35792| 978k| janet_fixarity(argc, 3); 35793| 978k| const Janet *tup = janet_gettuple(argv, 0); 35794| 978k| janet_tuple_head(tup)->sm_line = janet_getinteger(argv, 1); ------------------ | | 1800| 978k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 35795| | janet_tuple_head(tup)->sm_column = janet_getinteger(argv, 2); ------------------ | | 1800| 978k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 35796| 978k| return argv[0]; 35797| 978k|} janet_lib_tuple: 35828| 264|void janet_lib_tuple(JanetTable *env) { 35829| 264| JanetRegExt tuple_cfuns[] = { 35830| 264| JANET_CORE_REG("tuple/brackets", cfun_tuple_brackets), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35831| 264| JANET_CORE_REG("tuple/slice", cfun_tuple_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35832| 264| JANET_CORE_REG("tuple/type", cfun_tuple_type), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35833| 264| JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35834| 264| JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35835| 264| JANET_CORE_REG("tuple/join", cfun_tuple_join), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 35836| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 35837| 264| }; 35838| | janet_core_cfuns_ext(env, NULL, tuple_cfuns); 35839| 264|} janet_hash_mix: 35965| 160M|uint32_t janet_hash_mix(uint32_t input, uint32_t more) { 35966| 160M| uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2)); 35967| 160M| return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2)); 35968| 160M|} janet_string_calchash: 35972| 31.8M|int32_t janet_string_calchash(const uint8_t *str, int32_t len) { 35973| 31.8M| if (NULL == str || len == 0) return 5381; ------------------ | Branch (35973:9): [True: 0, False: 31.8M] | Branch (35973:24): [True: 1.52M, False: 30.3M] ------------------ 35974| 30.3M| const uint8_t *end = str + len; 35975| 30.3M| uint32_t hash = 5381; 35976| 303M| while (str < end) ------------------ | Branch (35976:12): [True: 272M, False: 30.3M] ------------------ 35977| 272M| hash = (hash << 5) + hash + *str++; 35978| 30.3M| hash = janet_hash_mix(hash, (uint32_t) len); 35979| 30.3M| return (int32_t) hash; 35980| 31.8M|} janet_array_calchash: 36095| 11.9M|int32_t janet_array_calchash(const Janet *array, int32_t len) { 36096| 11.9M| const Janet *end = array + len; 36097| 11.9M| uint32_t hash = 33; 36098| 43.1M| while (array < end) { ------------------ | Branch (36098:12): [True: 31.2M, False: 11.9M] ------------------ 36099| 31.2M| hash = janet_hash_mix(hash, janet_hash(*array++)); 36100| 31.2M| } 36101| 11.9M| return (int32_t) hash; 36102| 11.9M|} janet_kv_calchash: 36105| 1.54M|int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) { 36106| 1.54M| const JanetKV *end = kvs + len; 36107| 1.54M| uint32_t hash = 33; 36108| 50.8M| while (kvs < end) { ------------------ | Branch (36108:12): [True: 49.2M, False: 1.54M] ------------------ 36109| 49.2M| hash = janet_hash_mix(hash, janet_hash(kvs->key)); 36110| 49.2M| hash = janet_hash_mix(hash, janet_hash(kvs->value)); 36111| 49.2M| kvs++; 36112| 49.2M| } 36113| 1.54M| return (int32_t) hash; 36114| 1.54M|} janet_tablen: 36118| 2.05M|int32_t janet_tablen(int32_t n) { 36119| 2.05M| if (n < 0) return 0; ------------------ | Branch (36119:9): [True: 0, False: 2.05M] ------------------ 36120| 2.05M| n |= n >> 1; 36121| 2.05M| n |= n >> 2; 36122| 2.05M| n |= n >> 4; 36123| 2.05M| n |= n >> 8; 36124| 2.05M| n |= n >> 16; 36125| 2.05M| return n == INT32_MAX ? INT32_MAX : n + 1; ------------------ | Branch (36125:12): [True: 0, False: 2.05M] ------------------ 36126| 2.05M|} safe_memcpy: 36129| 16.5M|void safe_memcpy(void *dest, const void *src, size_t len) { 36130| 16.5M| if (!len) return; ------------------ | Branch (36130:9): [True: 4.75M, False: 11.8M] ------------------ 36131| 11.8M| memcpy(dest, src, len); 36132| 11.8M|} janet_dict_find_deep: 36136| 672k|const JanetKV *janet_dict_find_deep(const JanetKV *buckets, int32_t cap, Janet key) { 36137| 672k| int32_t index = janet_maphash(cap, janet_hash(key)); ------------------ | | 396| 672k|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 36138| 672k| int32_t i; 36139| 672k| const JanetKV *first_bucket = NULL; 36140| | /* Higher half */ 36141| 1.58M| for (i = index; i < cap; i++) { ------------------ | Branch (36141:21): [True: 1.56M, False: 16.7k] ------------------ 36142| 1.56M| const JanetKV *kv = buckets + i; 36143| 1.56M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 1.56M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.02M, False: 549k] | | | Branch (806:6): [Folded, False: 1.56M] | | ------------------ | | 807| 1.56M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.56M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.56M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.56M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.56M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.56M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36144| 1.02M| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 1.02M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 550k, False: 469k] | | | Branch (806:6): [Folded, False: 1.02M] | | ------------------ | | 807| 1.02M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.02M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.02M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.02M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.02M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.02M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36145| 550k| return kv; 36146| 550k| } else if (NULL == first_bucket) { ------------------ | Branch (36146:24): [True: 137k, False: 332k] ------------------ 36147| 137k| first_bucket = kv; 36148| 137k| } 36149| 1.02M| } else if (janet_bitwise_same(kv->key, key) || janet_equals(kv->key, key)) { ------------------ | | 401| 1.09M|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 549k|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 549k|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 101k, False: 448k] | | ------------------ ------------------ | Branch (36149:56): [True: 3.09k, False: 444k] ------------------ 36150| 105k| return buckets + i; 36151| 105k| } 36152| 1.56M| } 36153| | /* Lower half */ 36154| 24.5k| for (i = 0; i < index; i++) { ------------------ | Branch (36154:17): [True: 24.5k, False: 0] ------------------ 36155| 24.5k| const JanetKV *kv = buckets + i; 36156| 24.5k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 24.5k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 19.6k, False: 4.88k] | | | Branch (806:6): [Folded, False: 24.5k] | | ------------------ | | 807| 24.5k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 24.5k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 24.5k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 24.5k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 24.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 24.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36157| 19.6k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 19.6k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 13.2k, False: 6.36k] | | | Branch (806:6): [Folded, False: 19.6k] | | ------------------ | | 807| 19.6k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 19.6k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 19.6k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 19.6k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 19.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36158| 13.2k| return kv; 36159| 13.2k| } else if (NULL == first_bucket) { ------------------ | Branch (36159:24): [True: 108, False: 6.25k] ------------------ 36160| 108| first_bucket = kv; 36161| 108| } 36162| 19.6k| } else if (janet_bitwise_same(kv->key, key) || janet_equals(kv->key, key)) { ------------------ | | 401| 9.77k|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 4.88k|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 4.88k|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 3.44k, False: 1.44k] | | ------------------ ------------------ | Branch (36162:56): [True: 2, False: 1.44k] ------------------ 36163| 3.44k| return buckets + i; 36164| 3.44k| } 36165| 24.5k| } 36166| 0| return first_bucket; 36167| 16.7k|} janet_dict_find_keyword: 36173| 2.46M| const uint8_t *cstr, int32_t cstr_len) { 36174| 2.46M| int32_t hash = janet_string_calchash(cstr, cstr_len); 36175| 2.46M| int32_t index = janet_maphash(cap, hash); ------------------ | | 396| 2.46M|#define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1)) ------------------ 36176| 2.46M| int32_t i; 36177| 2.46M| const JanetKV *first_bucket = NULL; 36178| | /* Higher half */ 36179| 3.86M| for (i = index; i < cap; i++) { ------------------ | Branch (36179:21): [True: 3.52M, False: 342k] ------------------ 36180| 3.52M| const JanetKV *kv = buckets + i; 36181| 3.52M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 3.52M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.37M, False: 2.15M] | | | Branch (806:6): [Folded, False: 3.52M] | | ------------------ | | 807| 3.52M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.52M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.52M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.52M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.52M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.52M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36182| 1.37M| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 1.37M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.37M, False: 0] | | | Branch (806:6): [Folded, False: 1.37M] | | ------------------ | | 807| 1.37M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.37M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.37M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.37M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.37M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.37M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36183| 1.37M| return kv; 36184| 1.37M| } else if (NULL == first_bucket) { ------------------ | Branch (36184:24): [True: 0, False: 0] ------------------ 36185| 0| first_bucket = kv; 36186| 0| } 36187| 2.15M| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 2.15M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.15M, False: 0] | | | Branch (806:6): [Folded, False: 2.15M] | | ------------------ | | 807| 2.15M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.15M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.15M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.15M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.15M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.15M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36188| | /* Works for symbol and keyword, too */ 36189| 2.15M| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 2.15M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36190| 2.15M| int32_t len = janet_string_length(str); ------------------ | | 1813| 2.15M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 2.15M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36191| 2.15M| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1814| 4.31M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 2.15M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (36191:17): [True: 749k, False: 1.40M] | Branch (36191:51): [True: 749k, False: 0] | Branch (36191:70): [True: 749k, False: 0] ------------------ 36192| 749k| return buckets + i; 36193| 749k| } 36194| 2.15M| } 36195| 3.52M| } 36196| | /* Lower half */ 36197| 342k| for (i = 0; i < index; i++) { ------------------ | Branch (36197:17): [True: 342k, False: 0] ------------------ 36198| 342k| const JanetKV *kv = buckets + i; 36199| 342k| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 342k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 342k, False: 140] | | | Branch (806:6): [Folded, False: 342k] | | ------------------ | | 807| 342k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 342k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 342k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 342k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 342k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 342k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36200| 342k| if (janet_checktype(kv->value, JANET_NIL)) { ------------------ | | 806| 342k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 342k, False: 0] | | | Branch (806:6): [Folded, False: 342k] | | ------------------ | | 807| 342k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 342k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 342k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 342k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 342k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 342k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36201| 342k| return kv; 36202| 342k| } else if (NULL == first_bucket) { ------------------ | Branch (36202:24): [True: 0, False: 0] ------------------ 36203| 0| first_bucket = kv; 36204| 0| } 36205| 342k| } else if (janet_checktype(kv->key, JANET_KEYWORD)) { ------------------ | | 806| 140| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 140, False: 0] | | | Branch (806:6): [Folded, False: 140] | | ------------------ | | 807| 140| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 140| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 140| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 140|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 140|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 140|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36206| | /* Works for symbol and keyword, too */ 36207| 140| JanetString str = janet_unwrap_string(kv->key); ------------------ | | 863| 140|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36208| 140| int32_t len = janet_string_length(str); ------------------ | | 1813| 140|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 140|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36209| 140| if (hash == janet_string_hash(str) && len == cstr_len && !memcmp(str, cstr, len)) { ------------------ | | 1814| 280|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 140|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (36209:17): [True: 0, False: 140] | Branch (36209:51): [True: 0, False: 0] | Branch (36209:70): [True: 0, False: 0] ------------------ 36210| 0| return buckets + i; 36211| 0| } 36212| 140| } 36213| 342k| } 36214| 0| return first_bucket; 36215| 342k|} janet_dictionary_next: 36227| 214|const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv) { 36228| 214| const JanetKV *end = kvs + cap; 36229| 214| kv = (kv == NULL) ? kvs : kv + 1; ------------------ | Branch (36229:10): [True: 45, False: 169] ------------------ 36230| 453| while (kv < end) { ------------------ | Branch (36230:12): [True: 408, False: 45] ------------------ 36231| 408| if (!janet_checktype(kv->key, JANET_NIL)) ------------------ | | 806| 408| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 408] | | ------------------ | | 807| 408| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 408| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 408| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 408|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 408|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 408|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36231:13): [True: 169, False: 239] ------------------ 36232| 169| return kv; 36233| 239| kv++; 36234| 239| } 36235| 45| return NULL; 36236| 214|} janet_cstrcmp: 36240| 6.45M|int janet_cstrcmp(const uint8_t *str, const char *other) { 36241| 6.45M| int32_t len = janet_string_length(str); ------------------ | | 1813| 6.45M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 6.45M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36242| 6.45M| int32_t index; 36243| 10.3M| for (index = 0; index < len; index++) { ------------------ | Branch (36243:21): [True: 9.84M, False: 534k] ------------------ 36244| 9.84M| uint8_t c = str[index]; 36245| 9.84M| uint8_t k = ((const uint8_t *)other)[index]; 36246| 9.84M| if (c < k) return -1; ------------------ | Branch (36246:13): [True: 2.55M, False: 7.29M] ------------------ 36247| 7.29M| if (c > k) return 1; ------------------ | Branch (36247:13): [True: 3.37M, False: 3.92M] ------------------ 36248| 3.92M| if (k == '\0') break; ------------------ | Branch (36248:13): [True: 0, False: 3.92M] ------------------ 36249| 3.92M| } 36250| 534k| return (other[index] == '\0') ? 0 : -1; ------------------ | Branch (36250:12): [True: 533k, False: 623] ------------------ 36251| 6.45M|} janet_strbinsearch: 36260| 725k| const uint8_t *key) { 36261| 725k| size_t low = 0; 36262| 725k| size_t hi = tabcount; 36263| 725k| const char *t = (const char *)tab; 36264| 2.47M| while (low < hi) { ------------------ | Branch (36264:12): [True: 2.25M, False: 218k] ------------------ 36265| 2.25M| size_t mid = low + ((hi - low) / 2); 36266| 2.25M| const char **item = (const char **)(t + mid * itemsize); 36267| 2.25M| const char *name = *item; 36268| 2.25M| int comp = janet_cstrcmp(key, name); 36269| 2.25M| if (comp < 0) { ------------------ | Branch (36269:13): [True: 1.04M, False: 1.21M] ------------------ 36270| 1.04M| hi = mid; 36271| 1.21M| } else if (comp > 0) { ------------------ | Branch (36271:20): [True: 707k, False: 506k] ------------------ 36272| 707k| low = mid + 1; 36273| 707k| } else { 36274| 506k| return (const void *)item; 36275| 506k| } 36276| 2.25M| } 36277| 218k| return NULL; 36278| 725k|} janet_registry_put: 36340| 92.9k| int32_t source_line) { 36341| 92.9k| if (janet_vm.registry_count == janet_vm.registry_cap) { ------------------ | Branch (36341:9): [True: 264, False: 92.6k] ------------------ 36342| 264| size_t newcap = (janet_vm.registry_count + 1) * 2; 36343| | /* Size it nicely with core by default */ 36344| 264| if (newcap < 512) { ------------------ | Branch (36344:13): [True: 264, False: 0] ------------------ 36345| 264| newcap = 512; 36346| 264| } 36347| 264| void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry)); ------------------ | | 2409| 264|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 36348| 264| if (NULL == newmem) { ------------------ | Branch (36348:13): [True: 0, False: 264] ------------------ 36349| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 36350| 0| } 36351| 264| janet_vm.registry = newmem; 36352| 264| janet_vm.registry_cap = newcap; 36353| 264| } 36354| 92.9k| JanetCFunRegistry value = { 36355| 92.9k| key, 36356| 92.9k| name, 36357| 92.9k| name_prefix, 36358| 92.9k| source_file, 36359| 92.9k| source_line 36360| 92.9k| }; 36361| 92.9k| janet_vm.registry[janet_vm.registry_count++] = value; 36362| 92.9k| janet_vm.registry_dirty = 1; 36363| 92.9k|} janet_register_abstract_type: 36489| 2.37k|void janet_register_abstract_type(const JanetAbstractType *at) { 36490| 2.37k| janet_check_pointer_align((void *) at); 36491| 2.37k| Janet sym = janet_csymbolv(at->name); ------------------ | | 1837| 2.37k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 2.37k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 2.37k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 2.37k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.37k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36492| 2.37k| Janet check = janet_table_get(janet_vm.abstract_registry, sym); 36493| 2.37k| if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 806| 4.75k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.37k] | | ------------------ | | 807| 4.75k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4.75k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.37k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.37k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.37k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.37k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!janet_checktype(check, JANET_NIL) && at != janet_unwrap_pointer(check)) { ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (36493:9): [True: 0, False: 2.37k] | Branch (36493:47): [True: 0, False: 0] ------------------ 36494| 0| janet_panicf("cannot register abstract type %s, " 36495| 0| "a type with the same name exists", at->name); 36496| 0| } 36497| 2.37k| janet_table_put(janet_vm.abstract_registry, sym, janet_wrap_pointer((void *) at)); ------------------ | | 854| 2.37k|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 2.37k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.37k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.37k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36498| 2.37k|} janet_core_def_sm: 36509| 792|void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) { 36510| 792| (void) sf; 36511| 792| (void) sl; 36512| 792| (void) p; 36513| 792| Janet key = janet_csymbolv(name); ------------------ | | 1837| 792|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 792|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 792| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 792|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 792|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36514| 792| janet_table_put(env, key, x); 36515| 792| if (janet_checktype(x, JANET_CFUNCTION)) { ------------------ | | 806| 792| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 792] | | | Branch (806:6): [Folded, False: 792] | | ------------------ | | 807| 792| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 792| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 792| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 792|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 792|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 792|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36516| 0| janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0); ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 36517| 0| } 36518| 792|} janet_core_cfuns_ext: 36520| 5.80k|void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) { 36521| 5.80k| (void) regprefix; 36522| 98.7k| while (cfuns->name) { ------------------ | Branch (36522:12): [True: 92.9k, False: 5.80k] ------------------ 36523| 92.9k| janet_check_pointer_align(cfuns->cfun); 36524| 92.9k| Janet fun = janet_wrap_cfunction(cfuns->cfun); ------------------ | | 853| 92.9k|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 92.9k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 92.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 92.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36525| 92.9k| janet_table_put(env, janet_csymbolv(cfuns->name), fun); ------------------ | | 1837| 92.9k|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 92.9k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 92.9k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 92.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 92.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36526| 92.9k| janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line); 36527| 92.9k| cfuns++; 36528| 92.9k| } 36529| 5.80k|} janet_binding_from_entry: 36532| 550k|JanetBinding janet_binding_from_entry(Janet entry) { 36533| 550k| JanetTable *entry_table; 36534| 550k| JanetBinding binding = { 36535| 550k| JANET_BINDING_NONE, 36536| 550k| janet_wrap_nil(), ------------------ | | 831| 550k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 550k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 550k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 550k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36537| 550k| JANET_BINDING_DEP_NONE 36538| 550k| }; 36539| | 36540| | /* Check environment for entry */ 36541| 550k| if (!janet_checktype(entry, JANET_TABLE)) ------------------ | | 806| 550k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 550k] | | ------------------ | | 807| 550k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 550k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 550k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 550k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 550k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 550k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36541:9): [True: 18.7k, False: 531k] ------------------ 36542| 18.7k| return binding; 36543| 531k| entry_table = janet_unwrap_table(entry); ------------------ | | 861| 531k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36544| | 36545| 531k| Janet deprecate = janet_table_get_keyword(entry_table, "deprecated"); 36546| 531k| int macro = janet_truthy(janet_table_get_keyword(entry_table, "macro")); ------------------ | | 818| 531k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 1.06M| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 531k] | | | | ------------------ | | | | 807| 1.06M| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 1.06M| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 531k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 531k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 531k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 531k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 72.5k, False: 459k] | | ------------------ | | 819| 531k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 145k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 72.5k] | | | | ------------------ | | | | 807| 145k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 145k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 72.5k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 72.5k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 72.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 72.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 72.5k] | | | Branch (819:47): [True: 72.5k, False: 0] | | ------------------ ------------------ 36547| 531k| Janet value = janet_table_get_keyword(entry_table, "value"); 36548| 531k| Janet ref = janet_table_get_keyword(entry_table, "ref"); 36549| | 36550| 531k| if (janet_checktype(deprecate, JANET_KEYWORD)) { ------------------ | | 806| 531k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 531k] | | | Branch (806:6): [Folded, False: 531k] | | ------------------ | | 807| 531k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 531k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 531k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 531k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 531k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 531k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36551| 0| JanetKeyword depkw = janet_unwrap_keyword(deprecate); ------------------ | | 865| 0|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 36552| 0| if (!janet_cstrcmp(depkw, "relaxed")) { ------------------ | Branch (36552:13): [True: 0, False: 0] ------------------ 36553| 0| binding.deprecation = JANET_BINDING_DEP_RELAXED; 36554| 0| } else if (!janet_cstrcmp(depkw, "normal")) { ------------------ | Branch (36554:20): [True: 0, False: 0] ------------------ 36555| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 36556| 0| } else if (!janet_cstrcmp(depkw, "strict")) { ------------------ | Branch (36556:20): [True: 0, False: 0] ------------------ 36557| 0| binding.deprecation = JANET_BINDING_DEP_STRICT; 36558| 0| } 36559| 531k| } else if (!janet_checktype(deprecate, JANET_NIL)) { ------------------ | | 806| 531k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 531k] | | ------------------ | | 807| 531k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 531k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 531k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 531k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 531k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 531k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36559:16): [True: 0, False: 531k] ------------------ 36560| 0| binding.deprecation = JANET_BINDING_DEP_NORMAL; 36561| 0| } 36562| | 36563| 531k| int ref_is_valid = janet_checktype(ref, JANET_ARRAY); ------------------ | | 806| 531k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 531k] | | ------------------ | | 807| 531k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 531k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 531k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 531k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 531k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 531k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36564| 531k| int redef = ref_is_valid && janet_truthy(janet_table_get_keyword(entry_table, "redef")); ------------------ | | 818| 597k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 131k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 65.7k] | | | | ------------------ | | | | 807| 131k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 131k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 65.7k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 65.7k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 65.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 65.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 65.7k] | | ------------------ | | 819| 597k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (36564:17): [True: 65.7k, False: 466k] ------------------ 36565| | 36566| 531k| if (macro) { ------------------ | Branch (36566:9): [True: 72.5k, False: 459k] ------------------ 36567| 72.5k| binding.value = redef ? ref : value; ------------------ | Branch (36567:25): [True: 0, False: 72.5k] ------------------ 36568| 72.5k| binding.type = redef ? JANET_BINDING_DYNAMIC_MACRO : JANET_BINDING_MACRO; ------------------ | Branch (36568:24): [True: 0, False: 72.5k] ------------------ 36569| 72.5k| return binding; 36570| 72.5k| } 36571| | 36572| 459k| if (ref_is_valid) { ------------------ | Branch (36572:9): [True: 65.7k, False: 393k] ------------------ 36573| 65.7k| binding.value = ref; 36574| 65.7k| binding.type = redef ? JANET_BINDING_DYNAMIC_DEF : JANET_BINDING_VAR; ------------------ | Branch (36574:24): [True: 0, False: 65.7k] ------------------ 36575| 393k| } else { 36576| 393k| binding.value = value; 36577| 393k| binding.type = JANET_BINDING_DEF; 36578| 393k| } 36579| | 36580| 459k| return binding; 36581| 531k|} janet_resolve_ext: 36636| 550k|JanetBinding janet_resolve_ext(JanetTable *env, const uint8_t *sym) { 36637| 550k| Janet entry = janet_table_get(env, janet_wrap_symbol(sym)); ------------------ | | 849| 550k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 550k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 550k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 550k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36638| 550k| return janet_binding_from_entry(entry); 36639| 550k|} janet_resolve: 36641| 219k|JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) { 36642| 219k| JanetBinding binding = janet_resolve_ext(env, sym); 36643| 219k| if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (36643:9): [True: 0, False: 219k] | Branch (36643:54): [True: 0, False: 219k] ------------------ 36644| 0| *out = janet_array_peek(janet_unwrap_array(binding.value)); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36645| 219k| } else { 36646| 219k| *out = binding.value; 36647| 219k| } 36648| 219k| return binding.type; 36649| 219k|} janet_indexed_view: 36661| 5.59M|int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) { 36662| 5.59M| if (janet_checktype(seq, JANET_ARRAY)) { ------------------ | | 806| 5.59M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.33M, False: 4.25M] | | | Branch (806:6): [Folded, False: 5.59M] | | ------------------ | | 807| 5.59M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.59M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.59M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.59M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.59M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.59M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36663| 1.33M| *data = janet_unwrap_array(seq)->data; ------------------ | | 860| 1.33M|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36664| 1.33M| *len = janet_unwrap_array(seq)->count; ------------------ | | 860| 1.33M|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 36665| 1.33M| return 1; 36666| 4.25M| } else if (janet_checktype(seq, JANET_TUPLE)) { ------------------ | | 806| 4.25M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.25M, False: 0] | | | Branch (806:6): [Folded, False: 4.25M] | | ------------------ | | 807| 4.25M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4.25M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 4.25M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 4.25M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 4.25M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.25M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36667| 4.25M| *data = janet_unwrap_tuple(seq); ------------------ | | 858| 4.25M|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 36668| 4.25M| *len = janet_tuple_length(janet_unwrap_tuple(seq)); ------------------ | | 1802| 4.25M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 4.25M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 36669| 4.25M| return 1; 36670| 4.25M| } 36671| 0| return 0; 36672| 5.59M|} janet_bytes_view: 36676| 723k|int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) { 36677| 723k| JanetType t = janet_type(str); ------------------ | | 795| 723k| (isnan((x).number) \ | | 796| 723k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 723k| : JANET_NUMBER) ------------------ | Branch (36677:19): [True: 723k, False: 0] ------------------ 36678| 723k| if (t == JANET_STRING || t == JANET_SYMBOL || t == JANET_KEYWORD) { ------------------ | Branch (36678:9): [True: 44.6k, False: 678k] | Branch (36678:30): [True: 673k, False: 5.53k] | Branch (36678:51): [True: 2, False: 5.53k] ------------------ 36679| 717k| *data = janet_unwrap_string(str); ------------------ | | 863| 717k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 36680| 717k| *len = janet_string_length(janet_unwrap_string(str)); ------------------ | | 1813| 717k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 717k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 36681| 717k| return 1; 36682| 717k| } else if (t == JANET_BUFFER) { ------------------ | Branch (36682:16): [True: 5.53k, False: 0] ------------------ 36683| 5.53k| *data = janet_unwrap_buffer(str)->data; ------------------ | | 862| 5.53k|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 36684| 5.53k| *len = janet_unwrap_buffer(str)->count; ------------------ | | 862| 5.53k|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 36685| 5.53k| return 1; 36686| 5.53k| } else if (t == JANET_ABSTRACT) { ------------------ | Branch (36686:16): [True: 0, False: 0] ------------------ 36687| 0| void *abst = janet_unwrap_abstract(str); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 36688| 0| const JanetAbstractType *atype = janet_abstract_type(abst); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 36689| 0| if (NULL == atype->bytes) { ------------------ | Branch (36689:13): [True: 0, False: 0] ------------------ 36690| 0| return 0; 36691| 0| } 36692| 0| JanetByteView view = atype->bytes(abst, janet_abstract_size(abst)); ------------------ | | 1900| 0|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 36693| 0| *data = view.bytes; 36694| 0| *len = view.len; 36695| 0| return 1; 36696| 0| } 36697| 0| return 0; 36698| 723k|} janet_dictionary_view: 36703| 722|int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) { 36704| 722| if (janet_checktype(tab, JANET_TABLE)) { ------------------ | | 806| 722| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 559, False: 163] | | | Branch (806:6): [Folded, False: 722] | | ------------------ | | 807| 722| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 722| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 722| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 722|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 722|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 722|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36705| 559| *data = janet_unwrap_table(tab)->data; ------------------ | | 861| 559|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36706| 559| *cap = janet_unwrap_table(tab)->capacity; ------------------ | | 861| 559|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36707| 559| *len = janet_unwrap_table(tab)->count; ------------------ | | 861| 559|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 36708| 559| return 1; 36709| 559| } else if (janet_checktype(tab, JANET_STRUCT)) { ------------------ | | 806| 163| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 163, False: 0] | | | Branch (806:6): [Folded, False: 163] | | ------------------ | | 807| 163| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 163| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 163| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 163|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 163|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 163|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 36710| 163| *data = janet_unwrap_struct(tab); ------------------ | | 857| 163|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 36711| 163| *cap = janet_struct_capacity(janet_unwrap_struct(tab)); ------------------ | | 1849| 163|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 163|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 36712| 163| *len = janet_struct_length(janet_unwrap_struct(tab)); ------------------ | | 1848| 163|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 163|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 36713| 163| return 1; 36714| 163| } 36715| 0| return 0; 36716| 722|} janet_checkint: 36718| 19.3M|int janet_checkint(Janet x) { 36719| 19.3M| if (!janet_checktype(x, JANET_NUMBER)) ------------------ | | 806| 19.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [True: 19.3M, Folded] | | ------------------ | | 807| 19.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 19.3M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 19.2M, False: 97.5k] | | | | | Branch (803:28): [True: 0, False: 97.5k] | | | | ------------------ | | ------------------ | | 808| 19.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36719:9): [True: 97.5k, False: 19.2M] ------------------ 36720| 97.5k| return 0; 36721| 19.2M| double dval = janet_unwrap_number(x); ------------------ | | 839| 19.2M|#define janet_unwrap_number(x) ((x).number) ------------------ 36722| | return janet_checkintrange(dval); ------------------ | | 962| 19.2M|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | ------------------ | | | Branch (962:33): [True: 19.2M, False: 155] | | | Branch (962:53): [True: 19.2M, False: 945] | | | Branch (962:73): [True: 19.2M, False: 0] | | ------------------ ------------------ 36723| 19.3M|} janet_sorted_keys: 36800| 462|int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer) { 36801| | 36802| | /* First, put populated indices into index_buffer */ 36803| 462| int32_t next_index = 0; 36804| 8.06k| for (int32_t i = 0; i < cap; i++) { ------------------ | Branch (36804:25): [True: 7.60k, False: 462] ------------------ 36805| 7.60k| if (!janet_checktype(dict[i].key, JANET_NIL)) { ------------------ | | 806| 7.60k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 7.60k] | | ------------------ | | 807| 7.60k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 7.60k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 7.60k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 7.60k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 7.60k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.60k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (36805:13): [True: 2.37k, False: 5.23k] ------------------ 36806| 2.37k| index_buffer[next_index++] = i; 36807| 2.37k| } 36808| 7.60k| } 36809| | 36810| | /* Next, sort those (simple insertion sort here for now) */ 36811| 2.42k| for (int32_t i = 1; i < next_index; i++) { ------------------ | Branch (36811:25): [True: 1.95k, False: 462] ------------------ 36812| 1.95k| int32_t index_to_insert = index_buffer[i]; 36813| 1.95k| Janet lhs = dict[index_to_insert].key; 36814| 264k| for (int32_t j = i - 1; j >= 0; j--) { ------------------ | Branch (36814:33): [True: 264k, False: 44] ------------------ 36815| 264k| index_buffer[j + 1] = index_buffer[j]; 36816| 264k| Janet rhs = dict[index_buffer[j]].key; 36817| 264k| if (janet_compare(lhs, rhs) >= 0) { ------------------ | Branch (36817:17): [True: 1.91k, False: 262k] ------------------ 36818| 1.91k| index_buffer[j + 1] = index_to_insert; 36819| 1.91k| break; 36820| 262k| } else if (j == 0) { ------------------ | Branch (36820:24): [True: 44, False: 262k] ------------------ 36821| 44| index_buffer[0] = index_to_insert; 36822| 44| } 36823| 264k| } 36824| 1.95k| } 36825| | 36826| | /* Return number of indices found */ 36827| 462| return next_index; 36828| | 36829| 462|} array_allocate: 37062| 3.64M|void *array_allocate(size_t element_size, int32_t count) { 37063| 3.64M| if (count < 0) return NULL; ------------------ | Branch (37063:9): [True: 0, False: 3.64M] ------------------ 37064| 3.64M| if ((size_t) count > (SIZE_MAX / element_size)) return NULL; ------------------ | Branch (37064:9): [True: 0, False: 3.64M] ------------------ 37065| 3.64M| return janet_malloc(element_size * count); ------------------ | | 2406| 3.64M|#define janet_malloc(X) malloc((X)) ------------------ 37066| 3.64M|} janet_next_impl: 37201| 4.21M|Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) { 37202| 4.21M| JanetType t = janet_type(ds); ------------------ | | 795| 4.21M| (isnan((x).number) \ | | 796| 4.21M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 4.21M| : JANET_NUMBER) ------------------ | Branch (37202:19): [True: 4.21M, False: 1] ------------------ 37203| 4.21M| switch (t) { 37204| 1| default: ------------------ | Branch (37204:9): [True: 1, False: 4.21M] ------------------ 37205| 1| janet_panicf("expected iterable type, got %v", ds); 37206| 2.00k| case JANET_TABLE: ------------------ | Branch (37206:9): [True: 2.00k, False: 4.21M] ------------------ 37207| 10.8k| case JANET_STRUCT: { ------------------ | Branch (37207:9): [True: 8.80k, False: 4.20M] ------------------ 37208| 10.8k| const JanetKV *start; 37209| 10.8k| int32_t cap; 37210| 10.8k| if (t == JANET_TABLE) { ------------------ | Branch (37210:17): [True: 2.00k, False: 8.80k] ------------------ 37211| 2.00k| JanetTable *tab = janet_unwrap_table(ds); ------------------ | | 861| 2.00k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 37212| 2.00k| cap = tab->capacity; 37213| 2.00k| start = tab->data; 37214| 8.80k| } else { 37215| 8.80k| JanetStruct st = janet_unwrap_struct(ds); ------------------ | | 857| 8.80k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37216| 8.80k| cap = janet_struct_capacity(st); ------------------ | | 1849| 8.80k|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 8.80k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37217| 8.80k| start = st; 37218| 8.80k| } 37219| 10.8k| const JanetKV *end = start + cap; 37220| 10.8k| const JanetKV *kv = janet_checktype(key, JANET_NIL) ------------------ | | 806| 10.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.01k, False: 8.79k] | | | Branch (806:6): [Folded, False: 10.8k] | | ------------------ | | 807| 10.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 10.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 10.8k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 10.8k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 10.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 10.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37221| 10.8k| ? start 37222| 10.8k| : janet_dict_find(start, cap, key) + 1; 37223| 32.7k| while (kv < end) { ------------------ | Branch (37223:20): [True: 30.9k, False: 1.79k] ------------------ 37224| 30.9k| if (!janet_checktype(kv->key, JANET_NIL)) return kv->key; ------------------ | | 806| 30.9k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 30.9k] | | ------------------ | | 807| 30.9k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 30.9k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 30.9k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 30.9k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 30.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 30.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37224:21): [True: 9.01k, False: 21.9k] ------------------ 37225| 21.9k| kv++; 37226| 21.9k| } 37227| 1.79k| break; 37228| 10.8k| } 37229| 1.79k| case JANET_STRING: ------------------ | Branch (37229:9): [True: 0, False: 4.21M] ------------------ 37230| 0| case JANET_KEYWORD: ------------------ | Branch (37230:9): [True: 0, False: 4.21M] ------------------ 37231| 0| case JANET_SYMBOL: ------------------ | Branch (37231:9): [True: 0, False: 4.21M] ------------------ 37232| 0| case JANET_BUFFER: ------------------ | Branch (37232:9): [True: 0, False: 4.21M] ------------------ 37233| 130| case JANET_ARRAY: ------------------ | Branch (37233:9): [True: 130, False: 4.21M] ------------------ 37234| 4.20M| case JANET_TUPLE: { ------------------ | Branch (37234:9): [True: 4.20M, False: 10.9k] ------------------ 37235| 4.20M| int32_t i; 37236| 4.20M| if (janet_checktype(key, JANET_NIL)) { ------------------ | | 806| 4.20M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.81M, False: 2.39M] | | | Branch (806:6): [Folded, False: 4.20M] | | ------------------ | | 807| 4.20M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4.20M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 4.20M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 4.20M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 4.20M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.20M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37237| 1.81M| i = 0; 37238| 2.39M| } else if (janet_checkint(key)) { ------------------ | Branch (37238:24): [True: 2.39M, False: 0] ------------------ 37239| 2.39M| i = janet_unwrap_integer(key) + 1; ------------------ | | 966| 2.39M|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 2.39M|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 37240| 2.39M| } else { 37241| 0| break; 37242| 0| } 37243| 4.20M| int32_t len; 37244| 4.20M| if (t == JANET_BUFFER) { ------------------ | Branch (37244:17): [True: 0, False: 4.20M] ------------------ 37245| 0| len = janet_unwrap_buffer(ds)->count; ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 37246| 4.20M| } else if (t == JANET_ARRAY) { ------------------ | Branch (37246:24): [True: 130, False: 4.20M] ------------------ 37247| 130| len = janet_unwrap_array(ds)->count; ------------------ | | 860| 130|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 37248| 4.20M| } else if (t == JANET_TUPLE) { ------------------ | Branch (37248:24): [True: 4.20M, False: 0] ------------------ 37249| 4.20M| len = janet_tuple_length(janet_unwrap_tuple(ds)); ------------------ | | 1802| 4.20M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 4.20M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 37250| 4.20M| } else { 37251| 0| len = janet_string_length(janet_unwrap_string(ds)); ------------------ | | 1813| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 37252| 0| } 37253| 4.20M| if (i < len && i >= 0) { ------------------ | Branch (37253:17): [True: 3.15M, False: 1.05M] | Branch (37253:28): [True: 3.15M, False: 0] ------------------ 37254| 3.15M| return janet_wrap_integer(i); ------------------ | | 967| 3.15M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 3.15M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37255| 3.15M| } 37256| 1.05M| break; 37257| 4.20M| } 37258| 1.05M| case JANET_ABSTRACT: { ------------------ | Branch (37258:9): [True: 3, False: 4.21M] ------------------ 37259| 3| JanetAbstract abst = janet_unwrap_abstract(ds); ------------------ | | 866| 3|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37260| 3| const JanetAbstractType *at = janet_abstract_type(abst); ------------------ | | 1899| 3|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 3|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37261| 3| if (NULL == at->next) break; ------------------ | Branch (37261:17): [True: 0, False: 3] ------------------ 37262| 3| return at->next(abst, key); 37263| 3| } 37264| 0| case JANET_FIBER: { ------------------ | Branch (37264:9): [True: 0, False: 4.21M] ------------------ 37265| 0| JanetFiber *child = janet_unwrap_fiber(ds); ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 37266| 0| Janet retreg; 37267| 0| JanetFiberStatus status = janet_fiber_status(child); 37268| 0| if (status == JANET_STATUS_ALIVE || ------------------ | Branch (37268:17): [True: 0, False: 0] ------------------ 37269| 0| status == JANET_STATUS_DEAD || ------------------ | Branch (37269:21): [True: 0, False: 0] ------------------ 37270| 0| status == JANET_STATUS_ERROR || ------------------ | Branch (37270:21): [True: 0, False: 0] ------------------ 37271| 0| status == JANET_STATUS_USER0 || ------------------ | Branch (37271:21): [True: 0, False: 0] ------------------ 37272| 0| status == JANET_STATUS_USER1 || ------------------ | Branch (37272:21): [True: 0, False: 0] ------------------ 37273| 0| status == JANET_STATUS_USER2 || ------------------ | Branch (37273:21): [True: 0, False: 0] ------------------ 37274| 0| status == JANET_STATUS_USER3 || ------------------ | Branch (37274:21): [True: 0, False: 0] ------------------ 37275| 0| status == JANET_STATUS_USER4) { ------------------ | Branch (37275:21): [True: 0, False: 0] ------------------ 37276| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37277| 0| } 37278| 0| janet_vm.fiber->child = child; 37279| 0| JanetSignal sig = janet_continue(child, janet_wrap_nil(), &retreg); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37280| 0| if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { ------------------ | Branch (37280:17): [True: 0, False: 0] | Branch (37280:43): [True: 0, False: 0] ------------------ 37281| 0| if (is_interpreter) { ------------------ | Branch (37281:21): [True: 0, False: 0] ------------------ 37282| 0| janet_signalv(sig, retreg); 37283| 0| } else { 37284| 0| janet_vm.fiber->child = NULL; 37285| 0| janet_panicv(retreg); 37286| 0| } 37287| 0| } 37288| 0| janet_vm.fiber->child = NULL; 37289| 0| if (sig == JANET_SIGNAL_OK || ------------------ | Branch (37289:17): [True: 0, False: 0] ------------------ 37290| 0| sig == JANET_SIGNAL_ERROR || ------------------ | Branch (37290:21): [True: 0, False: 0] ------------------ 37291| 0| sig == JANET_SIGNAL_USER0 || ------------------ | Branch (37291:21): [True: 0, False: 0] ------------------ 37292| 0| sig == JANET_SIGNAL_USER1 || ------------------ | Branch (37292:21): [True: 0, False: 0] ------------------ 37293| 0| sig == JANET_SIGNAL_USER2 || ------------------ | Branch (37293:21): [True: 0, False: 0] ------------------ 37294| 0| sig == JANET_SIGNAL_USER3 || ------------------ | Branch (37294:21): [True: 0, False: 0] ------------------ 37295| 0| sig == JANET_SIGNAL_USER4) { ------------------ | Branch (37295:21): [True: 0, False: 0] ------------------ 37296| | /* Fiber cannot be resumed, so discard last value. */ 37297| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37298| 0| } else { 37299| 0| return janet_wrap_integer(0); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37300| 0| } 37301| 0| } 37302| 4.21M| } 37303| 1.05M| return janet_wrap_nil(); ------------------ | | 831| 1.05M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.05M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.05M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.05M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37304| 4.21M|} janet_equals: 37368| 42.5M|int janet_equals(Janet x, Janet y) { 37369| 42.5M| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 42.5M| (isnan((x).number) \ | | 796| 42.5M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 42.5M| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 42.5M| (isnan((x).number) \ | | 796| 42.5M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 42.5M| : JANET_NUMBER) ------------------ | Branch (37369:9): [True: 40.9M, False: 1.58M] | Branch (37369:9): [True: 2.67M, False: 39.8M] | Branch (37369:26): [True: 40.1M, False: 2.40M] ------------------ 37370| 39.8M| if (janet_checktypes(x, JANET_TFLAG_TUPLE | JANET_TFLAG_STRUCT)) return janet_equals_containers(x, y); ------------------ | | 969| 39.8M|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | ------------------ | | | | 795| 39.8M| (isnan((x).number) \ | | | | 796| 39.8M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | 797| 39.8M| : JANET_NUMBER) | | ------------------ | | | Branch (969:34): [True: 434k, False: 39.4M] | | ------------------ ------------------ | Branch (37370:9): [True: 38.2M, False: 1.57M] ------------------ 37371| 39.4M| return janet_equals_leaf(x, y); 37372| 39.8M|} janet_hash: 37384| 150M|int32_t janet_hash(Janet x) { 37385| 150M| int32_t hash = 0; 37386| 150M| switch (janet_type(x)) { ------------------ | | 795| 150M| (isnan((x).number) \ | | 796| 150M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 150M| : JANET_NUMBER) ------------------ | Branch (37386:13): [True: 145M, False: 5.68M] ------------------ 37387| 64.6M| case JANET_NIL: ------------------ | Branch (37387:9): [True: 64.6M, False: 86.0M] ------------------ 37388| 64.6M| hash = 0; 37389| 64.6M| break; 37390| 1.61k| case JANET_BOOLEAN: ------------------ | Branch (37390:9): [True: 1.61k, False: 150M] ------------------ 37391| 1.61k| hash = janet_unwrap_boolean(x); ------------------ | | 838| 1.61k|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 37392| 1.61k| break; 37393| 5.51M| case JANET_STRING: ------------------ | Branch (37393:9): [True: 5.51M, False: 145M] ------------------ 37394| 51.5M| case JANET_SYMBOL: ------------------ | Branch (37394:9): [True: 45.9M, False: 104M] ------------------ 37395| 52.3M| case JANET_KEYWORD: ------------------ | Branch (37395:9): [True: 838k, False: 149M] ------------------ 37396| 52.3M| hash = janet_string_hash(janet_unwrap_string(x)); ------------------ | | 1814| 52.3M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 52.3M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 37397| 52.3M| break; 37398| 9.85M| case JANET_TUPLE: ------------------ | Branch (37398:9): [True: 9.85M, False: 140M] ------------------ 37399| 9.85M| hash = janet_tuple_hash(janet_unwrap_tuple(x)); ------------------ | | 1803| 9.85M|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 9.85M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 37400| 9.85M| uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1806| 9.85M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 9.85M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ uint32_t inc = (janet_tuple_flag(janet_unwrap_tuple(x)) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : 0; ------------------ | | 1798| 9.85M|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (37400:28): [True: 1.15M, False: 8.70M] ------------------ 37401| 9.85M| hash = (int32_t)((uint32_t)hash + inc); /* avoid overflow undefined behavior */ 37402| 9.85M| break; 37403| 3.94k| case JANET_STRUCT: ------------------ | Branch (37403:9): [True: 3.94k, False: 150M] ------------------ 37404| 3.94k| hash = janet_struct_hash(janet_unwrap_struct(x)); ------------------ | | 1850| 3.94k|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 3.94k|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37405| 3.94k| break; 37406| 5.68M| case JANET_NUMBER: { ------------------ | Branch (37406:9): [True: 5.68M, False: 145M] ------------------ 37407| 5.68M| union { 37408| 5.68M| double d; 37409| 5.68M| uint64_t u; 37410| 5.68M| } as; 37411| 5.68M| as.d = janet_unwrap_number(x); ------------------ | | 839| 5.68M|#define janet_unwrap_number(x) ((x).number) ------------------ 37412| 5.68M| as.d += 0.0; /* normalize negative 0 */ 37413| 5.68M| as.u = murmur64(as.u); 37414| 5.68M| uint32_t hi = (uint32_t)(as.u >> 32); 37415| 5.68M| hash = (int32_t)hi; 37416| 5.68M| break; 37417| 51.5M| } 37418| 5.79k| case JANET_ABSTRACT: { ------------------ | Branch (37418:9): [True: 5.79k, False: 150M] ------------------ 37419| 5.79k| JanetAbstract xx = janet_unwrap_abstract(x); ------------------ | | 866| 5.79k|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37420| 5.79k| const JanetAbstractType *at = janet_abstract_type(xx); ------------------ | | 1899| 5.79k|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 5.79k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37421| 5.79k| if (at->hash != NULL) { ------------------ | Branch (37421:17): [True: 4.21k, False: 1.58k] ------------------ 37422| 4.21k| hash = at->hash(xx, janet_abstract_size(xx)); ------------------ | | 1900| 4.21k|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1897| 4.21k|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37423| 4.21k| break; 37424| 4.21k| } 37425| 5.79k| } 37426| | /* fallthrough */ 37427| 18.1M| default: ------------------ | Branch (37427:9): [True: 18.1M, False: 132M] ------------------ 37428| 18.1M| if (sizeof(double) == sizeof(void *)) { ------------------ | Branch (37428:17): [True: 18.1M, Folded] ------------------ 37429| | /* Assuming 8 byte pointer (8 byte aligned) */ 37430| 18.1M| uint64_t i = murmur64(janet_u64(x)); ------------------ | | 788| 18.1M|#define janet_u64(x) ((x).u64) ------------------ 37431| 18.1M| hash = (int32_t)(i >> 32); 37432| 18.1M| } else { 37433| | /* Assuming 4 byte pointer (or smaller) */ 37434| 0| uintptr_t diff = (uintptr_t) janet_unwrap_pointer(x); ------------------ | | 867| 0|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ 37435| 0| uint32_t hilo = (uint32_t) diff * 2654435769u; 37436| 0| hash = (int32_t)((hilo << 16) | (hilo >> 16)); 37437| 0| } 37438| 18.1M| break; 37439| 150M| } 37440| 150M| return hash; 37441| 150M|} janet_compare: 37446| 860k|int janet_compare(Janet x, Janet y) { 37447| 860k| janet_vm.traversal = janet_vm.traversal_base; 37448| 860k| int status; 37449| 1.88M| do { 37450| 1.88M| JanetType tx = janet_type(x); ------------------ | | 795| 1.88M| (isnan((x).number) \ | | 796| 1.88M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 1.88M| : JANET_NUMBER) ------------------ | Branch (37450:24): [True: 1.88M, False: 61] ------------------ 37451| 1.88M| JanetType ty = janet_type(y); ------------------ | | 795| 1.88M| (isnan((x).number) \ | | 796| 1.88M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 1.88M| : JANET_NUMBER) ------------------ | Branch (37451:24): [True: 1.88M, False: 13] ------------------ 37452| 1.88M| if (tx != ty) return tx < ty ? -1 : 1; ------------------ | Branch (37452:13): [True: 35.8k, False: 1.85M] | Branch (37452:30): [True: 35.7k, False: 97] ------------------ 37453| 1.85M| switch (tx) { 37454| 2| case JANET_NIL: ------------------ | Branch (37454:13): [True: 2, False: 1.85M] ------------------ 37455| 2| break; 37456| 0| case JANET_BOOLEAN: { ------------------ | Branch (37456:13): [True: 0, False: 1.85M] ------------------ 37457| 0| int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 0|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ int diff = janet_unwrap_boolean(x) - janet_unwrap_boolean(y); ------------------ | | 838| 0|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) ------------------ 37458| 0| if (diff) return diff; ------------------ | Branch (37458:21): [True: 0, False: 0] ------------------ 37459| 0| break; 37460| 0| } 37461| 13| case JANET_NUMBER: { ------------------ | Branch (37461:13): [True: 13, False: 1.85M] ------------------ 37462| 13| double xx = janet_unwrap_number(x); ------------------ | | 839| 13|#define janet_unwrap_number(x) ((x).number) ------------------ 37463| 13| double yy = janet_unwrap_number(y); ------------------ | | 839| 13|#define janet_unwrap_number(x) ((x).number) ------------------ 37464| 13| if (xx == yy) { ------------------ | Branch (37464:21): [True: 9, False: 4] ------------------ 37465| 9| break; 37466| 9| } else { 37467| 4| return (xx < yy) ? -1 : 1; ------------------ | Branch (37467:28): [True: 4, False: 0] ------------------ 37468| 4| } 37469| 13| } 37470| 226k| case JANET_STRING: ------------------ | Branch (37470:13): [True: 226k, False: 1.62M] ------------------ 37471| 1.10M| case JANET_SYMBOL: ------------------ | Branch (37471:13): [True: 880k, False: 969k] ------------------ 37472| 1.10M| case JANET_KEYWORD: { ------------------ | Branch (37472:13): [True: 7, False: 1.85M] ------------------ 37473| 1.10M| int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 1.10M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ int diff = janet_string_compare(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 1.10M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37474| 1.10M| if (diff) return diff; ------------------ | Branch (37474:21): [True: 1.15k, False: 1.10M] ------------------ 37475| 1.10M| break; 37476| 1.10M| } 37477| 1.10M| case JANET_ABSTRACT: { ------------------ | Branch (37477:13): [True: 0, False: 1.85M] ------------------ 37478| 0| int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ int diff = janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37479| 0| if (diff) return diff; ------------------ | Branch (37479:21): [True: 0, False: 0] ------------------ 37480| 0| break; 37481| 0| } 37482| 229k| default: { ------------------ | Branch (37482:13): [True: 229k, False: 1.62M] ------------------ 37483| 229k| if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 229k|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ if (janet_unwrap_pointer(x) == janet_unwrap_pointer(y)) { ------------------ | | 867| 229k|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37483:21): [True: 0, False: 229k] ------------------ 37484| 0| break; 37485| 229k| } else { 37486| 229k| return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 229k|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ return janet_unwrap_pointer(x) > janet_unwrap_pointer(y) ? 1 : -1; ------------------ | | 867| 229k|#define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37486:28): [True: 1.67k, False: 227k] ------------------ 37487| 229k| } 37488| 229k| } 37489| 513k| case JANET_TUPLE: { ------------------ | Branch (37489:13): [True: 513k, False: 1.33M] ------------------ 37490| 513k| const Janet *lhs = janet_unwrap_tuple(x); ------------------ | | 858| 513k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37491| 513k| const Janet *rhs = janet_unwrap_tuple(y); ------------------ | | 858| 513k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37492| 513k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1798| 513k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1806| 513k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 513k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(lhs) ^ janet_tuple_flag(rhs))) { ------------------ | | 1806| 513k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 513k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37492:21): [True: 216, False: 513k] ------------------ 37493| 216| return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1806| 216|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 216|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ return (janet_tuple_flag(lhs) & JANET_TUPLE_FLAG_BRACKETCTOR) ? 1 : -1; ------------------ | | 1798| 216|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (37493:28): [True: 1, False: 215] ------------------ 37494| 216| } 37495| 513k| push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1800| 513k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(lhs), janet_tuple_head(rhs), 1); ------------------ | | 1800| 513k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 37496| 513k| break; 37497| 513k| } 37498| 2| case JANET_STRUCT: { ------------------ | Branch (37498:13): [True: 2, False: 1.85M] ------------------ 37499| 2| const JanetKV *lhs = janet_unwrap_struct(x); ------------------ | | 857| 2|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37500| 2| const JanetKV *rhs = janet_unwrap_struct(y); ------------------ | | 857| 2|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37501| 2| int32_t llen = janet_struct_capacity(lhs); ------------------ | | 1849| 2|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 2|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37502| 2| int32_t rlen = janet_struct_capacity(rhs); ------------------ | | 1849| 2|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 2|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37503| 2| int32_t lhash = janet_struct_hash(lhs); ------------------ | | 1850| 2|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 2|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37504| 2| int32_t rhash = janet_struct_hash(rhs); ------------------ | | 1850| 2|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 2|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37505| 2| if (llen < rlen) return -1; ------------------ | Branch (37505:21): [True: 0, False: 2] ------------------ 37506| 2| if (llen > rlen) return 1; ------------------ | Branch (37506:21): [True: 1, False: 1] ------------------ 37507| 1| if (lhash < rhash) return -1; ------------------ | Branch (37507:21): [True: 0, False: 1] ------------------ 37508| 1| if (lhash > rhash) return 1; ------------------ | Branch (37508:21): [True: 0, False: 1] ------------------ 37509| 1| push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1846| 1|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(lhs), janet_struct_head(rhs), 0); ------------------ | | 1846| 1|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 37510| 1| break; 37511| 1| } 37512| 1.85M| } 37513| 1.85M| } while (!(status = traversal_next(&x, &y))); ------------------ | Branch (37513:14): [True: 1.02M, False: 593k] ------------------ 37514| 593k| return status - 2; 37515| 860k|} janet_in: 37528| 15.4M|Janet janet_in(Janet ds, Janet key) { 37529| 15.4M| Janet value; 37530| 15.4M| JanetType type = janet_type(ds); ------------------ | | 795| 15.4M| (isnan((x).number) \ | | 796| 15.4M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 15.4M| : JANET_NUMBER) ------------------ | Branch (37530:22): [True: 15.4M, False: 0] ------------------ 37531| 15.4M| switch (type) { 37532| 0| default: ------------------ | Branch (37532:9): [True: 0, False: 15.4M] ------------------ 37533| 0| janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds); ------------------ | | 615| 0|#define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 612| 0|#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 599| 0|#define JANET_TFLAG_STRING (1 << JANET_STRING) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 600| 0|#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 606| 0|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 601| 0|#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 613| 0|#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 602| 0|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) | | | | ------------------ | | | | #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 603| 0|#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 614| 0|#define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 604| 0|#define JANET_TFLAG_TABLE (1 << JANET_TABLE) | | | | ------------------ | | | | #define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 605| 0|#define JANET_TFLAG_STRUCT (1 << JANET_STRUCT) | | | | ------------------ | | ------------------ ------------------ 37534| 0| break; 37535| 1.23M| case JANET_STRUCT: ------------------ | Branch (37535:9): [True: 1.23M, False: 14.2M] ------------------ 37536| 1.23M| value = janet_struct_get(janet_unwrap_struct(ds), key); ------------------ | | 857| 1.23M|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37537| 1.23M| break; 37538| 290k| case JANET_TABLE: ------------------ | Branch (37538:9): [True: 290k, False: 15.1M] ------------------ 37539| 290k| value = janet_table_get(janet_unwrap_table(ds), key); ------------------ | | 861| 290k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 37540| 290k| break; 37541| 488k| case JANET_ARRAY: { ------------------ | Branch (37541:9): [True: 488k, False: 14.9M] ------------------ 37542| 488k| JanetArray *array = janet_unwrap_array(ds); ------------------ | | 860| 488k|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 37543| 488k| int32_t index = getter_checkint(type, key, array->count); 37544| 488k| value = array->data[index]; 37545| 488k| break; 37546| 0| } 37547| 10.9M| case JANET_TUPLE: { ------------------ | Branch (37547:9): [True: 10.9M, False: 4.47M] ------------------ 37548| 10.9M| const Janet *tuple = janet_unwrap_tuple(ds); ------------------ | | 858| 10.9M|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37549| 10.9M| int32_t len = janet_tuple_length(tuple); ------------------ | | 1802| 10.9M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 10.9M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 37550| 10.9M| value = tuple[getter_checkint(type, key, len)]; 37551| 10.9M| break; 37552| 0| } 37553| 826k| case JANET_BUFFER: { ------------------ | Branch (37553:9): [True: 826k, False: 14.6M] ------------------ 37554| 826k| JanetBuffer *buffer = janet_unwrap_buffer(ds); ------------------ | | 862| 826k|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 37555| 826k| int32_t index = getter_checkint(type, key, buffer->count); 37556| 826k| value = janet_wrap_integer(buffer->data[index]); ------------------ | | 967| 826k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 826k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37557| 826k| break; 37558| 0| } 37559| 1.63M| case JANET_STRING: ------------------ | Branch (37559:9): [True: 1.63M, False: 13.8M] ------------------ 37560| 1.63M| case JANET_SYMBOL: ------------------ | Branch (37560:9): [True: 0, False: 15.4M] ------------------ 37561| 1.63M| case JANET_KEYWORD: { ------------------ | Branch (37561:9): [True: 0, False: 15.4M] ------------------ 37562| 1.63M| const uint8_t *str = janet_unwrap_string(ds); ------------------ | | 863| 1.63M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37563| 1.63M| int32_t index = getter_checkint(type, key, janet_string_length(str)); ------------------ | | 1813| 1.63M|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 1.63M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 37564| 1.63M| value = janet_wrap_integer(str[index]); ------------------ | | 967| 1.63M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 1.63M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37565| 1.63M| break; 37566| 1.63M| } 37567| 3| case JANET_ABSTRACT: { ------------------ | Branch (37567:9): [True: 3, False: 15.4M] ------------------ 37568| 3| JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); ------------------ | | 1899| 3|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 3|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37569| 3| if (type->get) { ------------------ | Branch (37569:17): [True: 3, False: 0] ------------------ 37570| 3| if (!(type->get)(janet_unwrap_abstract(ds), key, &value)) ------------------ | | 866| 3|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ | Branch (37570:21): [True: 3, False: 0] ------------------ 37571| 3| janet_panicf("key %v not found in %v ", key, ds); 37572| 3| } else { 37573| 0| janet_panicf("no getter for %v", ds); 37574| 0| } 37575| 0| break; 37576| 3| } 37577| 0| case JANET_FIBER: { ------------------ | Branch (37577:9): [True: 0, False: 15.4M] ------------------ 37578| | /* Bit of a hack to allow iterating over fibers. */ 37579| 0| if (janet_equals(key, janet_wrap_integer(0))) { ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ | Branch (37579:17): [True: 0, False: 0] ------------------ 37580| 0| return janet_unwrap_fiber(ds)->last_value; ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 37581| 0| } else { 37582| 0| janet_panicf("expected key 0, got %v", key); 37583| 0| } 37584| 0| } 37585| 15.4M| } 37586| 15.4M| return value; 37587| 15.4M|} janet_get: 37589| 1.71M|Janet janet_get(Janet ds, Janet key) { 37590| 1.71M| JanetType t = janet_type(ds); ------------------ | | 795| 1.71M| (isnan((x).number) \ | | 796| 1.71M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 1.71M| : JANET_NUMBER) ------------------ | Branch (37590:19): [True: 1.71M, False: 20] ------------------ 37591| 1.71M| switch (t) { 37592| 20| default: ------------------ | Branch (37592:9): [True: 20, False: 1.71M] ------------------ 37593| 20| return janet_wrap_nil(); ------------------ | | 831| 20|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 20| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 20|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37594| 0| case JANET_STRING: ------------------ | Branch (37594:9): [True: 0, False: 1.71M] ------------------ 37595| 0| case JANET_SYMBOL: ------------------ | Branch (37595:9): [True: 0, False: 1.71M] ------------------ 37596| 0| case JANET_KEYWORD: { ------------------ | Branch (37596:9): [True: 0, False: 1.71M] ------------------ 37597| 0| if (!janet_checkint(key)) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37597:17): [True: 0, False: 0] ------------------ 37598| 0| int32_t index = janet_unwrap_integer(key); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 37599| 0| if (index < 0) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37599:17): [True: 0, False: 0] ------------------ 37600| 0| const uint8_t *str = janet_unwrap_string(ds); ------------------ | | 863| 0|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37601| 0| if (index >= janet_string_length(str)) return janet_wrap_nil(); ------------------ | | 1813| 0|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 0|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ if (index >= janet_string_length(str)) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37601:17): [True: 0, False: 0] ------------------ 37602| 0| return janet_wrap_integer(str[index]); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37603| 0| } 37604| 132| case JANET_ABSTRACT: { ------------------ | Branch (37604:9): [True: 132, False: 1.71M] ------------------ 37605| 132| Janet value; 37606| 132| void *abst = janet_unwrap_abstract(ds); ------------------ | | 866| 132|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37607| 132| JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(abst); ------------------ | | 1899| 132|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 132|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37608| 132| if (!type->get) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37608:17): [True: 0, False: 132] ------------------ 37609| 132| if ((type->get)(abst, key, &value)) ------------------ | Branch (37609:17): [True: 0, False: 132] ------------------ 37610| 0| return value; 37611| 132| return janet_wrap_nil(); ------------------ | | 831| 132|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 132| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 132|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 132|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37612| 132| } 37613| 0| case JANET_ARRAY: ------------------ | Branch (37613:9): [True: 0, False: 1.71M] ------------------ 37614| 196k| case JANET_TUPLE: ------------------ | Branch (37614:9): [True: 196k, False: 1.51M] ------------------ 37615| 196k| case JANET_BUFFER: { ------------------ | Branch (37615:9): [True: 0, False: 1.71M] ------------------ 37616| 196k| if (!janet_checkint(key)) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37616:17): [True: 0, False: 196k] ------------------ 37617| 196k| int32_t index = janet_unwrap_integer(key); ------------------ | | 966| 196k|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 196k|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 37618| 196k| if (index < 0) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37618:17): [True: 0, False: 196k] ------------------ 37619| 196k| if (t == JANET_ARRAY) { ------------------ | Branch (37619:17): [True: 0, False: 196k] ------------------ 37620| 0| JanetArray *a = janet_unwrap_array(ds); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 37621| 0| if (index >= a->count) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37621:21): [True: 0, False: 0] ------------------ 37622| 0| return a->data[index]; 37623| 196k| } else if (t == JANET_BUFFER) { ------------------ | Branch (37623:24): [True: 0, False: 196k] ------------------ 37624| 0| JanetBuffer *b = janet_unwrap_buffer(ds); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 37625| 0| if (index >= b->count) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37625:21): [True: 0, False: 0] ------------------ 37626| 0| return janet_wrap_integer(b->data[index]); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37627| 196k| } else { 37628| 196k| const Janet *t = janet_unwrap_tuple(ds); ------------------ | | 858| 196k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37629| 196k| if (index >= janet_tuple_length(t)) return janet_wrap_nil(); ------------------ | | 1802| 196k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 196k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (index >= janet_tuple_length(t)) return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (37629:21): [True: 0, False: 196k] ------------------ 37630| 196k| return t[index]; 37631| 196k| } 37632| 196k| } 37633| 578k| case JANET_TABLE: { ------------------ | Branch (37633:9): [True: 578k, False: 1.13M] ------------------ 37634| 578k| return janet_table_get(janet_unwrap_table(ds), key); ------------------ | | 861| 578k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 37635| 196k| } 37636| 937k| case JANET_STRUCT: { ------------------ | Branch (37636:9): [True: 937k, False: 774k] ------------------ 37637| 937k| const JanetKV *st = janet_unwrap_struct(ds); ------------------ | | 857| 937k|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37638| 937k| return janet_struct_get(st, key); 37639| 196k| } 37640| 0| case JANET_FIBER: { ------------------ | Branch (37640:9): [True: 0, False: 1.71M] ------------------ 37641| | /* Bit of a hack to allow iterating over fibers. */ 37642| 0| if (janet_equals(key, janet_wrap_integer(0))) { ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ | Branch (37642:17): [True: 0, False: 0] ------------------ 37643| 0| return janet_unwrap_fiber(ds)->last_value; ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 37644| 0| } else { 37645| 0| return janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37646| 0| } 37647| 0| } 37648| 1.71M| } 37649| 1.71M|} janet_getindex: 37651| 64.4k|Janet janet_getindex(Janet ds, int32_t index) { 37652| 64.4k| Janet value; 37653| 64.4k| if (index < 0) janet_panic("expected non-negative index"); ------------------ | Branch (37653:9): [True: 0, False: 64.4k] ------------------ 37654| 64.4k| switch (janet_type(ds)) { ------------------ | | 795| 64.4k| (isnan((x).number) \ | | 796| 64.4k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 64.4k| : JANET_NUMBER) ------------------ | Branch (37654:13): [True: 62.3k, False: 2.14k] ------------------ 37655| 2.14k| default: ------------------ | Branch (37655:9): [True: 2.14k, False: 62.3k] ------------------ 37656| 2.14k| janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds); ------------------ | | 615| 2.14k|#define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 612| 2.14k|#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 599| 2.14k|#define JANET_TFLAG_STRING (1 << JANET_STRING) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 600| 2.14k|#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 606| 2.14k|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 601| 2.14k|#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 613| 2.14k|#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 602| 2.14k|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) | | | | ------------------ | | | | #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 603| 2.14k|#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 614| 2.14k|#define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 604| 2.14k|#define JANET_TFLAG_TABLE (1 << JANET_TABLE) | | | | ------------------ | | | | #define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 605| 2.14k|#define JANET_TFLAG_STRUCT (1 << JANET_STRUCT) | | | | ------------------ | | ------------------ ------------------ 37657| 0| break; 37658| 0| case JANET_STRING: ------------------ | Branch (37658:9): [True: 0, False: 64.4k] ------------------ 37659| 411| case JANET_SYMBOL: ------------------ | Branch (37659:9): [True: 411, False: 64.0k] ------------------ 37660| 8.56k| case JANET_KEYWORD: ------------------ | Branch (37660:9): [True: 8.15k, False: 56.3k] ------------------ 37661| 8.56k| if (index >= janet_string_length(janet_unwrap_string(ds))) { ------------------ | | 1813| 8.56k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 8.56k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ | Branch (37661:17): [True: 1.62k, False: 6.93k] ------------------ 37662| 1.62k| value = janet_wrap_nil(); ------------------ | | 831| 1.62k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.62k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.62k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.62k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37663| 6.93k| } else { 37664| 6.93k| value = janet_wrap_integer(janet_unwrap_string(ds)[index]); ------------------ | | 967| 6.93k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 6.93k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37665| 6.93k| } 37666| 8.56k| break; 37667| 100| case JANET_ARRAY: ------------------ | Branch (37667:9): [True: 100, False: 64.3k] ------------------ 37668| 100| if (index >= janet_unwrap_array(ds)->count) { ------------------ | | 860| 100|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ | Branch (37668:17): [True: 0, False: 100] ------------------ 37669| 0| value = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37670| 100| } else { 37671| 100| value = janet_unwrap_array(ds)->data[index]; ------------------ | | 860| 100|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 37672| 100| } 37673| 100| break; 37674| 0| case JANET_BUFFER: ------------------ | Branch (37674:9): [True: 0, False: 64.4k] ------------------ 37675| 0| if (index >= janet_unwrap_buffer(ds)->count) { ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ | Branch (37675:17): [True: 0, False: 0] ------------------ 37676| 0| value = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37677| 0| } else { 37678| 0| value = janet_wrap_integer(janet_unwrap_buffer(ds)->data[index]); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37679| 0| } 37680| 0| break; 37681| 53.6k| case JANET_TUPLE: ------------------ | Branch (37681:9): [True: 53.6k, False: 10.8k] ------------------ 37682| 53.6k| if (index >= janet_tuple_length(janet_unwrap_tuple(ds))) { ------------------ | | 1802| 53.6k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 53.6k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37682:17): [True: 128, False: 53.5k] ------------------ 37683| 128| value = janet_wrap_nil(); ------------------ | | 831| 128|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 128| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 128|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 128|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37684| 53.5k| } else { 37685| 53.5k| value = janet_unwrap_tuple(ds)[index]; ------------------ | | 858| 53.5k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37686| 53.5k| } 37687| 53.6k| break; 37688| 0| case JANET_TABLE: ------------------ | Branch (37688:9): [True: 0, False: 64.4k] ------------------ 37689| 0| value = janet_table_get(janet_unwrap_table(ds), janet_wrap_integer(index)); ------------------ | | 861| 0|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ value = janet_table_get(janet_unwrap_table(ds), janet_wrap_integer(index)); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37690| 0| break; 37691| 0| case JANET_STRUCT: ------------------ | Branch (37691:9): [True: 0, False: 64.4k] ------------------ 37692| 0| value = janet_struct_get(janet_unwrap_struct(ds), janet_wrap_integer(index)); ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ value = janet_struct_get(janet_unwrap_struct(ds), janet_wrap_integer(index)); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37693| 0| break; 37694| 0| case JANET_ABSTRACT: { ------------------ | Branch (37694:9): [True: 0, False: 64.4k] ------------------ 37695| 0| JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37696| 0| if (type->get) { ------------------ | Branch (37696:17): [True: 0, False: 0] ------------------ 37697| 0| if (!(type->get)(janet_unwrap_abstract(ds), janet_wrap_integer(index), &value)) ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ if (!(type->get)(janet_unwrap_abstract(ds), janet_wrap_integer(index), &value)) ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ | Branch (37697:21): [True: 0, False: 0] ------------------ 37698| 0| value = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37699| 0| } else { 37700| 0| janet_panicf("no getter for %v", ds); 37701| 0| } 37702| 0| break; 37703| 0| } 37704| 0| case JANET_FIBER: { ------------------ | Branch (37704:9): [True: 0, False: 64.4k] ------------------ 37705| 0| if (index == 0) { ------------------ | Branch (37705:17): [True: 0, False: 0] ------------------ 37706| 0| value = janet_unwrap_fiber(ds)->last_value; ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 37707| 0| } else { 37708| 0| value = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37709| 0| } 37710| 0| break; 37711| 0| } 37712| 64.4k| } 37713| 62.3k| return value; 37714| 64.4k|} janet_length: 37716| 2.20M|int32_t janet_length(Janet x) { 37717| 2.20M| switch (janet_type(x)) { ------------------ | | 795| 2.20M| (isnan((x).number) \ | | 796| 2.20M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 2.20M| : JANET_NUMBER) ------------------ | Branch (37717:13): [True: 2.20M, False: 0] ------------------ 37718| 0| default: ------------------ | Branch (37718:9): [True: 0, False: 2.20M] ------------------ 37719| 0| janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x); ------------------ | | 615| 0|#define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 612| 0|#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 599| 0|#define JANET_TFLAG_STRING (1 << JANET_STRING) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 600| 0|#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 606| 0|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 601| 0|#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 613| 0|#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 602| 0|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) | | | | ------------------ | | | | #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 603| 0|#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 614| 0|#define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 604| 0|#define JANET_TFLAG_TABLE (1 << JANET_TABLE) | | | | ------------------ | | | | #define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 605| 0|#define JANET_TFLAG_STRUCT (1 << JANET_STRUCT) | | | | ------------------ | | ------------------ ------------------ 37720| 0| case JANET_STRING: ------------------ | Branch (37720:9): [True: 0, False: 2.20M] ------------------ 37721| 435| case JANET_SYMBOL: ------------------ | Branch (37721:9): [True: 435, False: 2.20M] ------------------ 37722| 435| case JANET_KEYWORD: ------------------ | Branch (37722:9): [True: 0, False: 2.20M] ------------------ 37723| 435| return janet_string_length(janet_unwrap_string(x)); ------------------ | | 1813| 435|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 435|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 37724| 563k| case JANET_ARRAY: ------------------ | Branch (37724:9): [True: 563k, False: 1.64M] ------------------ 37725| 563k| return janet_unwrap_array(x)->count; ------------------ | | 860| 563k|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 37726| 0| case JANET_BUFFER: ------------------ | Branch (37726:9): [True: 0, False: 2.20M] ------------------ 37727| 0| return janet_unwrap_buffer(x)->count; ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 37728| 1.64M| case JANET_TUPLE: ------------------ | Branch (37728:9): [True: 1.64M, False: 563k] ------------------ 37729| 1.64M| return janet_tuple_length(janet_unwrap_tuple(x)); ------------------ | | 1802| 1.64M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 1.64M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 37730| 0| case JANET_STRUCT: ------------------ | Branch (37730:9): [True: 0, False: 2.20M] ------------------ 37731| 0| return janet_struct_length(janet_unwrap_struct(x)); ------------------ | | 1848| 0|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 37732| 0| case JANET_TABLE: ------------------ | Branch (37732:9): [True: 0, False: 2.20M] ------------------ 37733| 0| return janet_unwrap_table(x)->count; ------------------ | | 861| 0|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 37734| 0| case JANET_ABSTRACT: { ------------------ | Branch (37734:9): [True: 0, False: 2.20M] ------------------ 37735| 0| void *abst = janet_unwrap_abstract(x); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37736| 0| const JanetAbstractType *type = janet_abstract_type(abst); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37737| 0| if (type->length != NULL) { ------------------ | Branch (37737:17): [True: 0, False: 0] ------------------ 37738| 0| size_t len = type->length(abst, janet_abstract_size(abst)); ------------------ | | 1900| 0|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37739| 0| if (len > INT32_MAX) { ------------------ | Branch (37739:21): [True: 0, False: 0] ------------------ 37740| 0| janet_panicf("invalid integer length %u", len); 37741| 0| } 37742| 0| return (int32_t)(len); 37743| 0| } 37744| 0| Janet argv[1] = { x }; 37745| 0| Janet len = janet_mcall("length", 1, argv); 37746| 0| if (!janet_checkint(len)) ------------------ | Branch (37746:17): [True: 0, False: 0] ------------------ 37747| 0| janet_panicf("invalid integer length %v", len); 37748| 0| return janet_unwrap_integer(len); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 37749| 0| } 37750| 2.20M| } 37751| 2.20M|} janet_lengthv: 37753| 5.54M|Janet janet_lengthv(Janet x) { 37754| 5.54M| switch (janet_type(x)) { ------------------ | | 795| 5.54M| (isnan((x).number) \ | | 796| 5.54M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 5.54M| : JANET_NUMBER) ------------------ | Branch (37754:13): [True: 5.54M, False: 0] ------------------ 37755| 0| default: ------------------ | Branch (37755:9): [True: 0, False: 5.54M] ------------------ 37756| 0| janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x); ------------------ | | 615| 0|#define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 612| 0|#define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 599| 0|#define JANET_TFLAG_STRING (1 << JANET_STRING) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 600| 0|#define JANET_TFLAG_SYMBOL (1 << JANET_SYMBOL) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 606| 0|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) | | | | ------------------ | | | | #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD) | | | | ------------------ | | | | | | 601| 0|#define JANET_TFLAG_KEYWORD (1 << JANET_KEYWORD) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 613| 0|#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 602| 0|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) | | | | ------------------ | | | | #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | | | ------------------ | | | | | | 603| 0|#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) | | | | ------------------ | | ------------------ | | #define JANET_TFLAG_LENGTHABLE (JANET_TFLAG_BYTES | JANET_TFLAG_INDEXED | JANET_TFLAG_DICTIONARY) | | ------------------ | | | | 614| 0|#define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 604| 0|#define JANET_TFLAG_TABLE (1 << JANET_TABLE) | | | | ------------------ | | | | #define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT) | | | | ------------------ | | | | | | 605| 0|#define JANET_TFLAG_STRUCT (1 << JANET_STRUCT) | | | | ------------------ | | ------------------ ------------------ 37757| 15| case JANET_STRING: ------------------ | Branch (37757:9): [True: 15, False: 5.54M] ------------------ 37758| 15| case JANET_SYMBOL: ------------------ | Branch (37758:9): [True: 0, False: 5.54M] ------------------ 37759| 15| case JANET_KEYWORD: ------------------ | Branch (37759:9): [True: 0, False: 5.54M] ------------------ 37760| 15| return janet_wrap_integer(janet_string_length(janet_unwrap_string(x))); ------------------ | | 967| 15|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 15|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37761| 15| case JANET_ARRAY: ------------------ | Branch (37761:9): [True: 15, False: 5.54M] ------------------ 37762| 15| return janet_wrap_integer(janet_unwrap_array(x)->count); ------------------ | | 967| 15|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 15|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37763| 5.74k| case JANET_BUFFER: ------------------ | Branch (37763:9): [True: 5.74k, False: 5.54M] ------------------ 37764| 5.74k| return janet_wrap_integer(janet_unwrap_buffer(x)->count); ------------------ | | 967| 5.74k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 5.74k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37765| 5.53M| case JANET_TUPLE: ------------------ | Branch (37765:9): [True: 5.53M, False: 8.03k] ------------------ 37766| 5.53M| return janet_wrap_integer(janet_tuple_length(janet_unwrap_tuple(x))); ------------------ | | 967| 5.53M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 5.53M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37767| 586| case JANET_STRUCT: ------------------ | Branch (37767:9): [True: 586, False: 5.54M] ------------------ 37768| 586| return janet_wrap_integer(janet_struct_length(janet_unwrap_struct(x))); ------------------ | | 967| 586|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 586|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37769| 1.54k| case JANET_TABLE: ------------------ | Branch (37769:9): [True: 1.54k, False: 5.54M] ------------------ 37770| 1.54k| return janet_wrap_integer(janet_unwrap_table(x)->count); ------------------ | | 967| 1.54k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 1.54k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 37771| 132| case JANET_ABSTRACT: { ------------------ | Branch (37771:9): [True: 132, False: 5.54M] ------------------ 37772| 132| void *abst = janet_unwrap_abstract(x); ------------------ | | 866| 132|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37773| 132| const JanetAbstractType *type = janet_abstract_type(abst); ------------------ | | 1899| 132|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 132|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37774| 132| if (type->length != NULL) { ------------------ | Branch (37774:17): [True: 0, False: 132] ------------------ 37775| 0| size_t len = type->length(abst, janet_abstract_size(abst)); ------------------ | | 1900| 0|#define janet_abstract_size(u) (janet_abstract_head(u)->size) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37776| | /* If len is always less then double, we can never overflow */ 37777| |#ifdef JANET_32 37778| | return janet_wrap_number(len); 37779| |#else 37780| 0| if (len < (size_t) JANET_INTMAX_INT64) { ------------------ | | 167| 0|#define JANET_INTMAX_INT64 9007199254740992 ------------------ | Branch (37780:21): [True: 0, False: 0] ------------------ 37781| 0| return janet_wrap_number((double) len); ------------------ | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 37782| 0| } else { 37783| 0| janet_panicf("integer length %u too large", len); 37784| 0| } 37785| 0|#endif 37786| 0| } 37787| 132| Janet argv[1] = { x }; 37788| 132| return janet_mcall("length", 1, argv); 37789| 132| } 37790| 5.54M| } 37791| 5.54M|} janet_put: 37839| 17.8k|void janet_put(Janet ds, Janet key, Janet value) { 37840| 17.8k| JanetType type = janet_type(ds); ------------------ | | 795| 17.8k| (isnan((x).number) \ | | 796| 17.8k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 17.8k| : JANET_NUMBER) ------------------ | Branch (37840:22): [True: 17.8k, False: 0] ------------------ 37841| 17.8k| switch (type) { 37842| 0| default: ------------------ | Branch (37842:9): [True: 0, False: 17.8k] ------------------ 37843| 0| janet_panicf("expected %T, got %v", 37844| 0| JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds); ------------------ | | 602| 0|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) ------------------ JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds); ------------------ | | 606| 0|#define JANET_TFLAG_BUFFER (1 << JANET_BUFFER) ------------------ JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds); ------------------ | | 604| 0|#define JANET_TFLAG_TABLE (1 << JANET_TABLE) ------------------ 37845| 12.8k| case JANET_ARRAY: { ------------------ | Branch (37845:9): [True: 12.8k, False: 4.93k] ------------------ 37846| 12.8k| JanetArray *array = janet_unwrap_array(ds); ------------------ | | 860| 12.8k|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 37847| 12.8k| int32_t index = getter_checkint(type, key, INT32_MAX - 1); 37848| 12.8k| if (index >= array->count) { ------------------ | Branch (37848:17): [True: 0, False: 12.8k] ------------------ 37849| 0| janet_array_ensure(array, index + 1, 2); 37850| 0| for (int32_t i = array->count; i < index + 1; i++) { ------------------ | Branch (37850:48): [True: 0, False: 0] ------------------ 37851| 0| array->data[i] = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37852| 0| } 37853| 0| array->count = index + 1; 37854| 0| } 37855| 12.8k| array->data[index] = value; 37856| 12.8k| break; 37857| 0| } 37858| 0| case JANET_BUFFER: { ------------------ | Branch (37858:9): [True: 0, False: 17.8k] ------------------ 37859| 0| JanetBuffer *buffer = janet_unwrap_buffer(ds); ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 37860| 0| int32_t index = getter_checkint(type, key, INT32_MAX - 1); 37861| 0| if (!janet_checkint(value)) ------------------ | Branch (37861:17): [True: 0, False: 0] ------------------ 37862| 0| janet_panicf("can only put integers in buffers, got %v", value); 37863| 0| if (index >= buffer->count) { ------------------ | Branch (37863:17): [True: 0, False: 0] ------------------ 37864| 0| janet_buffer_ensure(buffer, index + 1, 2); 37865| 0| memset(buffer->data + buffer->count, 0, index + 1 - buffer->count); 37866| 0| buffer->count = index + 1; 37867| 0| } 37868| 0| buffer->data[index] = (uint8_t)(janet_unwrap_integer(value) & 0xFF); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 37869| 0| break; 37870| 0| } 37871| 4.93k| case JANET_TABLE: ------------------ | Branch (37871:9): [True: 4.93k, False: 12.8k] ------------------ 37872| 4.93k| janet_table_put(janet_unwrap_table(ds), key, value); ------------------ | | 861| 4.93k|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 37873| 4.93k| break; 37874| 0| case JANET_ABSTRACT: { ------------------ | Branch (37874:9): [True: 0, False: 17.8k] ------------------ 37875| 0| JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds)); ------------------ | | 1899| 0|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 0|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37876| 0| if (type->put) { ------------------ | Branch (37876:17): [True: 0, False: 0] ------------------ 37877| 0| (type->put)(janet_unwrap_abstract(ds), key, value); ------------------ | | 866| 0|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37878| 0| } else { 37879| 0| janet_panicf("no setter for %v ", ds); 37880| 0| } 37881| 0| break; 37882| 0| } 37883| 17.8k| } 37884| 17.8k|} janet_v_grow: 37919| 4.36M|void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) { 37920| 4.36M| int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0; ------------------ | | 765| 2.04M|#define janet_v__cap(v) janet_v__raw(v)[0] | | ------------------ | | | | 764| 2.04M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (37920:23): [True: 2.04M, False: 2.32M] ------------------ 37921| 4.36M| int32_t min_needed = janet_v_count(v) + increment; ------------------ | | 759| 4.36M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.04M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.04M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.04M, False: 2.32M] | | ------------------ ------------------ 37922| 4.36M| int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed; ------------------ | Branch (37922:17): [True: 157k, False: 4.21M] ------------------ 37923| 4.36M| size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2; 37924| 4.36M| int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize); ------------------ | | 764| 2.04M|#define janet_v__raw(v) ((int32_t *)(v) - 2) ------------------ | Branch (37924:45): [True: 2.04M, False: 2.32M] ------------------ 37925| 4.36M| if (!v) p[1] = 0; ------------------ | Branch (37925:9): [True: 2.32M, False: 2.04M] ------------------ 37926| 4.36M| p[0] = m; 37927| 4.36M| return p + 2; 37928| 4.36M|} janet_v_flattenmem: 37931| 449k|void *janet_v_flattenmem(void *v, int32_t itemsize) { 37932| 449k| char *p; 37933| 449k| if (NULL == v) return NULL; ------------------ | Branch (37933:9): [True: 306k, False: 142k] ------------------ 37934| 142k| size_t size = (size_t) itemsize * janet_v__cnt(v); ------------------ | | 766| 142k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 142k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ 37935| 142k| p = janet_malloc(size); ------------------ | | 2406| 142k|#define janet_malloc(X) malloc((X)) ------------------ 37936| 142k| if (NULL != p) { ------------------ | Branch (37936:9): [True: 142k, False: 0] ------------------ 37937| 142k| safe_memcpy(p, v, size); 37938| 142k| return p; 37939| 142k| } else { 37940| | JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 37941| 0| } 37942| 142k|} janet_try_init: 39435| 68.9k|void janet_try_init(JanetTryState *state) { 39436| 68.9k| state->stackn = janet_vm.stackn++; 39437| 68.9k| state->gc_handle = janet_vm.gc_suspend; 39438| 68.9k| state->vm_fiber = janet_vm.fiber; 39439| 68.9k| state->vm_jmp_buf = janet_vm.signal_buf; 39440| 68.9k| state->vm_return_reg = janet_vm.return_reg; 39441| 68.9k| state->coerce_error = janet_vm.coerce_error; 39442| 68.9k| janet_vm.return_reg = &(state->payload); 39443| 68.9k| janet_vm.signal_buf = &(state->buf); 39444| 68.9k| janet_vm.coerce_error = 0; 39445| 68.9k|} janet_restore: 39447| 68.9k|void janet_restore(JanetTryState *state) { 39448| 68.9k| janet_vm.stackn = state->stackn; 39449| 68.9k| janet_vm.gc_suspend = state->gc_handle; 39450| 68.9k| janet_vm.fiber = state->vm_fiber; 39451| 68.9k| janet_vm.signal_buf = state->vm_jmp_buf; 39452| 68.9k| janet_vm.return_reg = state->vm_return_reg; 39453| 68.9k| janet_vm.coerce_error = state->coerce_error; 39454| 68.9k|} janet_continue: 39551| 68.6k|JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) { 39552| | /* Check conditions */ 39553| 68.6k| JanetSignal tmp_signal = janet_check_can_resume(fiber, out, 0); 39554| 68.6k| if (tmp_signal) return tmp_signal; ------------------ | Branch (39554:9): [True: 0, False: 68.6k] ------------------ 39555| 68.6k| return janet_continue_no_check(fiber, in, out); 39556| 68.6k|} janet_mcall: 39594| 132|Janet janet_mcall(const char *name, int32_t argc, Janet *argv) { 39595| | /* At least 1 argument */ 39596| 132| if (argc < 1) { ------------------ | Branch (39596:9): [True: 0, False: 132] ------------------ 39597| 0| janet_panicf("method :%s expected at least 1 argument", name); 39598| 0| } 39599| | /* Find method */ 39600| 132| Janet method = janet_method_lookup(argv[0], name); 39601| 132| if (janet_checktype(method, JANET_NIL)) { ------------------ | | 806| 132| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 132, False: 0] | | | Branch (806:6): [Folded, False: 132] | | ------------------ | | 807| 132| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 132| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 132| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 132|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 132|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 132|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39602| 132| janet_panicf("could not find method :%s for %v", name, argv[0]); 39603| 132| } 39604| | /* Invoke method */ 39605| 0| return janet_method_invoke(method, argc, argv); 39606| 132|} janet_init: 39609| 264|int janet_init(void) { 39610| | 39611| | /* Garbage collection */ 39612| 264| janet_vm.blocks = NULL; 39613| 264| janet_vm.weak_blocks = NULL; 39614| 264| janet_vm.next_collection = 0; 39615| 264| janet_vm.gc_interval = 0x400000; 39616| 264| janet_vm.block_count = 0; 39617| 264| janet_vm.gc_mark_phase = 0; 39618| | 39619| 264| janet_symcache_init(); 39620| | 39621| | /* Initialize gc roots */ 39622| 264| janet_vm.roots = NULL; 39623| 264| janet_vm.root_count = 0; 39624| 264| janet_vm.root_capacity = 0; 39625| | 39626| | /* Scratch memory */ 39627| 264| janet_vm.user = NULL; 39628| 264| janet_vm.scratch_mem = NULL; 39629| 264| janet_vm.scratch_len = 0; 39630| 264| janet_vm.scratch_cap = 0; 39631| | 39632| | /* Sandbox flags */ 39633| 264| janet_vm.sandbox_flags = 0; 39634| | 39635| | /* Initialize registry */ 39636| 264| janet_vm.registry = NULL; 39637| 264| janet_vm.registry_cap = 0; 39638| 264| janet_vm.registry_count = 0; 39639| 264| janet_vm.registry_dirty = 0; 39640| | 39641| | /* Initialize abstract registry */ 39642| 264| janet_vm.abstract_registry = janet_table(0); 39643| 264| janet_gcroot(janet_wrap_table(janet_vm.abstract_registry)); ------------------ | | 846| 264|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 264| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 264|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39644| | 39645| | /* Traversal */ 39646| 264| janet_vm.traversal = NULL; 39647| 264| janet_vm.traversal_base = NULL; 39648| 264| janet_vm.traversal_top = NULL; 39649| | 39650| | /* Core env */ 39651| 264| janet_vm.core_env = NULL; 39652| | 39653| | /* Auto suspension */ 39654| 264| janet_vm.auto_suspend = 0; 39655| | 39656| | /* Dynamic bindings */ 39657| 264| janet_vm.top_dyns = NULL; 39658| | 39659| | /* Seed RNG */ 39660| 264| janet_rng_seed(janet_default_rng(), 0); 39661| | 39662| | /* Fibers */ 39663| 264| janet_vm.fiber = NULL; 39664| 264| janet_vm.root_fiber = NULL; 39665| 264| janet_vm.stackn = 0; 39666| | 39667| 264|#ifdef JANET_EV 39668| 264| janet_ev_init(); 39669| 264|#endif 39670| 264|#ifdef JANET_NET 39671| 264| janet_net_init(); 39672| 264|#endif 39673| 264| return 0; 39674| 264|} janet_deinit: 39689| 264|void janet_deinit(void) { 39690| 264| janet_clear_memory(); 39691| 264| janet_symcache_deinit(); 39692| 264| janet_free(janet_vm.roots); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 39693| 264| janet_vm.roots = NULL; 39694| 264| janet_vm.root_count = 0; 39695| 264| janet_vm.root_capacity = 0; 39696| 264| janet_vm.abstract_registry = NULL; 39697| 264| janet_vm.core_env = NULL; 39698| 264| janet_vm.top_dyns = NULL; 39699| 264| janet_vm.user = NULL; 39700| 264| janet_free(janet_vm.traversal_base); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 39701| 264| janet_vm.fiber = NULL; 39702| 264| janet_vm.root_fiber = NULL; 39703| 264| janet_free(janet_vm.registry); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 39704| | janet_vm.registry = NULL; 39705| 264|#ifdef JANET_EV 39706| 264| janet_ev_deinit(); 39707| 264|#endif 39708| 264|#ifdef JANET_NET 39709| 264| janet_net_deinit(); 39710| 264|#endif 39711| 264|} janet_memalloc_empty: 39879| 456k|void *janet_memalloc_empty(int32_t count) { 39880| 456k| int32_t i; 39881| 456k| void *mem = array_allocate(sizeof(JanetKV), count); 39882| 456k| janet_vm.next_collection += (size_t) count * sizeof(JanetKV); 39883| 456k| if (NULL == mem) { ------------------ | Branch (39883:9): [True: 0, False: 456k] ------------------ 39884| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 39885| 0| } 39886| 456k| JanetKV *mmem = (JanetKV *)mem; 39887| 6.46M| for (i = 0; i < count; i++) { ------------------ | Branch (39887:17): [True: 6.00M, False: 456k] ------------------ 39888| 6.00M| JanetKV *kv = mmem + i; 39889| 6.00M| kv->key = janet_wrap_nil(); ------------------ | | 831| 6.00M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 6.00M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 6.00M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.00M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39890| 6.00M| kv->value = janet_wrap_nil(); ------------------ | | 831| 6.00M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 6.00M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 6.00M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.00M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39891| 6.00M| } 39892| 456k| return mem; 39893| 456k|} janet_memempty: 39895| 1.54M|void janet_memempty(JanetKV *mem, int32_t count) { 39896| 1.54M| int32_t i; 39897| 52.5M| for (i = 0; i < count; i++) { ------------------ | Branch (39897:17): [True: 50.9M, False: 1.54M] ------------------ 39898| 50.9M| mem[i].key = janet_wrap_nil(); ------------------ | | 831| 50.9M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 50.9M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 50.9M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.9M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39899| 50.9M| mem[i].value = janet_wrap_nil(); ------------------ | | 831| 50.9M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 50.9M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 50.9M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.9M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39900| 50.9M| } 39901| 1.54M|} janet_wrap_number_safe: 39905| 1.84k|Janet janet_wrap_number_safe(double d) { 39906| 1.84k| Janet ret; 39907| 1.84k| ret.number = isnan(d) ? NAN : d; ------------------ | Branch (39907:18): [True: 264, False: 1.58k] ------------------ 39908| 1.84k| return ret; 39909| 1.84k|} janet_nanbox_to_pointer: 39911| 234M|void *janet_nanbox_to_pointer(Janet x) { 39912| 234M| x.i64 &= JANET_NANBOX_PAYLOADBITS; ------------------ | | 791| 234M|#define JANET_NANBOX_PAYLOADBITS 0x00007FFFFFFFFFFFllu ------------------ 39913| 234M| x.u64 <<= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 234M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39914| 234M| return x.pointer; 39915| 234M|} janet_nanbox_from_pointer: 39917| 21.6M|Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask) { 39918| 21.6M| Janet ret; 39919| 21.6M| ret.pointer = p; 39920| | /* Should be noop when pointer shift is 0 */ 39921| | /* 39922| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 39923| | */ 39924| 21.6M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 21.6M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39925| 21.6M| ret.u64 |= tagmask; 39926| 21.6M| return ret; 39927| 21.6M|} janet_nanbox_from_cpointer: 39929| 43.3M|Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) { 39930| 43.3M| Janet ret; 39931| 43.3M| ret.pointer = (void *)p; 39932| | /* Should be noop when pointer shift is 0 */ 39933| | /* 39934| | janet_assert(!(ret.u64 & (uint64_t) ((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), "unaligned pointer wrap"); 39935| | */ 39936| 43.3M| ret.u64 >>= JANET_NANBOX_64_POINTER_SHIFT; /* Alignment, usually 0 */ ------------------ | | 341| 43.3M|#define JANET_NANBOX_64_POINTER_SHIFT 0 ------------------ 39937| 43.3M| ret.u64 |= tagmask; 39938| 43.3M| return ret; 39939| 43.3M|} janet_nanbox_from_double: 39941| 26.7M|Janet janet_nanbox_from_double(double d) { 39942| 26.7M| Janet ret; 39943| 26.7M| ret.number = d; 39944| 26.7M| return ret; 39945| 26.7M|} janet_nanbox_from_bits: 39947| 438M|Janet janet_nanbox_from_bits(uint64_t bits) { 39948| 438M| Janet ret; 39949| 438M| ret.u64 = bits; 39950| 438M| return ret; 39951| 438M|} janet.c:janet_array_impl: 1606| 18.4k|static void janet_array_impl(JanetArray *array, int32_t capacity) { 1607| 18.4k| Janet *data = NULL; 1608| 18.4k| if (capacity > 0) { ------------------ | Branch (1608:9): [True: 18.1k, False: 259] ------------------ 1609| 18.1k| janet_vm.next_collection += capacity * sizeof(Janet); 1610| 18.1k| data = (Janet *) array_allocate(sizeof(Janet), capacity); 1611| 18.1k| if (NULL == data) { ------------------ | Branch (1611:13): [True: 0, False: 18.1k] ------------------ 1612| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 1613| 0| } 1614| 18.1k| } 1615| 18.4k| array->count = 0; 1616| 18.4k| array->capacity = capacity; 1617| 18.4k| array->data = data; 1618| 18.4k|} janet.c:janet_buffer_init_impl: 3196| 95.2k|static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) { 3197| 95.2k| uint8_t *data = NULL; 3198| 95.2k| if (capacity < 4) capacity = 4; ------------------ | Branch (3198:9): [True: 5.40k, False: 89.8k] ------------------ 3199| 95.2k| janet_gcpressure(capacity); 3200| 95.2k| data = array_allocate(sizeof(uint8_t), capacity); 3201| 95.2k| if (NULL == data) { ------------------ | Branch (3201:9): [True: 0, False: 95.2k] ------------------ 3202| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 3203| 0| } 3204| 95.2k| buffer->count = 0; 3205| 95.2k| buffer->capacity = capacity; 3206| 95.2k| buffer->data = data; 3207| 95.2k| return buffer; 3208| 95.2k|} janet.c:janet_buffer_can_realloc: 3189| 23.6k|static void janet_buffer_can_realloc(JanetBuffer *buffer) { 3190| 23.6k| if (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC) { ------------------ | | 1780| 23.6k|#define JANET_BUFFER_FLAG_NO_REALLOC 0x10000 ------------------ | Branch (3190:9): [True: 0, False: 23.6k] ------------------ 3191| 0| janet_panic("buffer cannot reallocate foreign memory"); 3192| 0| } 3193| 23.6k|} janet.c:bs_set_bit: 3912| 41.6M|static void bs_set_bit(uint32_t *bitset, int32_t index) { 3913| 41.6M| bitset[bs_indx(index)] |= bs_mask(index); 3914| 41.6M|} janet.c:bs_mask: 3906| 99.8M|static uint32_t bs_mask(int32_t index) { 3907| 99.8M| return ((uint32_t)1) << (index & 0x1F); 3908| 99.8M|} janet.c:bs_indx: 3909| 99.8M|static uint32_t bs_indx(int32_t index) { 3910| 99.8M| return index >> 5; 3911| 99.8M|} janet.c:bs_read_bit: 3918| 17.4M|static int bs_read_bit(uint32_t *bitset, int32_t index) { 3919| 17.4M| return (bitset[bs_indx(index)] & bs_mask(index)) ? 1 : 0; ------------------ | Branch (3919:12): [True: 2.03M, False: 15.4M] ------------------ 3920| 17.4M|} janet.c:rewrite_symbolmap: 4765| 161k|static void rewrite_symbolmap(JanetFuncDef *def, uint32_t *pc_map) { 4766| 161k| int32_t smout = 0; 4767| 10.5M| for (int32_t i = 0; i < def->symbolmap_length; i++) { ------------------ | Branch (4767:25): [True: 10.4M, False: 161k] ------------------ 4768| 10.4M| JanetSymbolMap *sm = def->symbolmap + i; 4769| 10.4M| int keep = 1; 4770| | /* Don't rewrite upvalue mappings */ 4771| 10.4M| if (sm->birth_pc < UINT32_MAX) { ------------------ | Branch (4771:13): [True: 8.23M, False: 2.17M] ------------------ 4772| 8.23M| sm->birth_pc = pc_map[sm->birth_pc]; 4773| 8.23M| sm->death_pc = pc_map[sm->death_pc]; 4774| | /* entirely dead symbols can be removed from the symbol map. This can happen if a symbol is in dead code. */ 4775| 8.23M| if (sm->death_pc > (uint32_t) def->bytecode_length) sm->death_pc = (uint32_t) def->bytecode_length; ------------------ | Branch (4775:17): [True: 0, False: 8.23M] ------------------ 4776| 8.23M| if (sm->birth_pc >= sm->death_pc) keep = 0; ------------------ | Branch (4776:17): [True: 0, False: 8.23M] ------------------ 4777| 8.23M| } 4778| | /* Now shift if needed */ 4779| 10.4M| if (keep) def->symbolmap[smout++] = *sm; ------------------ | Branch (4779:13): [True: 10.4M, False: 0] ------------------ 4780| 10.4M| } 4781| 161k| def->symbolmap_length = smout; 4782| 161k|} janet.c:janet_bytecode_movopt_basic_block: 5053| 430k|static void janet_bytecode_movopt_basic_block(JanetFuncDef *def, BytecodeBB bb, uint32_t *bitset, int mode) { 5054| 430k| if (bb.start >= bb.end) return; /* Degenerate block */ ------------------ | Branch (5054:9): [True: 0, False: 430k] ------------------ 5055| 430k| if (mode == 0) { ------------------ | Branch (5055:9): [True: 215k, False: 215k] ------------------ 5056| | /* Flip bits */ 5057| 3.57M| for (int32_t word = 0; word < (((def->slotcount - 1) >> 5) + 1); word++) { ------------------ | Branch (5057:32): [True: 3.36M, False: 215k] ------------------ 5058| 3.36M| bitset[word] = ~bitset[word]; 5059| 3.36M| } 5060| 215k| } else { 5061| 215k| memset(bitset, 0x00, (def->slotcount + 7) / 8); 5062| 215k| } 5063| 54.1M| for (int32_t i = bb.end - 1; i >= bb.start; i--) { ------------------ | Branch (5063:34): [True: 53.7M, False: 430k] ------------------ 5064| 53.7M| int32_t ins[3]; 5065| 53.7M| int32_t out = -1; 5066| 53.7M| int nins = 0; 5067| 53.7M| int pin = 0; /* side effects, don't remove */ 5068| 53.7M| uint32_t I = def->bytecode[i]; 5069| 53.7M| uint32_t Iop = I & 0x7F; 5070| 53.7M| uint32_t Ia = (I >> 8) & 0xFF; 5071| 53.7M| uint32_t Ib = (I >> 16) & 0xFF; 5072| 53.7M| uint32_t Ic = (I >> 24); 5073| 53.7M| uint32_t Id = (I >> 8); 5074| 53.7M| uint32_t Ie = (I >> 16); 5075| | /* Whenever we execute an instruction that can yield or await, clear the bitset. 5076| | * Closures could read some slots that seem to be unused, and then control could 5077| | * return to our function. */ 5078| 53.7M| switch (Iop) { 5079| 0| default: ------------------ | Branch (5079:13): [True: 0, False: 53.7M] ------------------ 5080| 0| janet_assert(0, "unhandled instruction"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, Folded] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 5081| 0| continue; 5082| 438| case JOP_JUMP: ------------------ | Branch (5082:13): [True: 438, False: 53.7M] ------------------ 5083| 438| case JOP_NOOP: ------------------ | Branch (5083:13): [True: 0, False: 53.7M] ------------------ 5084| 23.1k| case JOP_RETURN_NIL: ------------------ | Branch (5084:13): [True: 22.7k, False: 53.7M] ------------------ 5085| 23.1k| continue; 5086| | 5087| | /* Side effects, don't remove */ 5088| | 5089| | /* Write A, Read E */ 5090| 273k| case JOP_CALL: ------------------ | Branch (5090:13): [True: 273k, False: 53.4M] ------------------ 5091| | /* Similar logic applies to tail calls, but they are always at the end of blocks anyway */ 5092| 273k| out = Ia; 5093| 273k| pin = 1; 5094| 273k| nins = 1; 5095| 273k| ins[0] = Ie; 5096| 273k| break; 5097| | /* Write A, Read B */ 5098| 4| case JOP_SIGNAL: ------------------ | Branch (5098:13): [True: 4, False: 53.7M] ------------------ 5099| 4| out = Ia; 5100| 4| nins = 1; 5101| 4| ins[0] = Ib; 5102| 4| pin = 1; 5103| 4| break; 5104| | /* Read A */ 5105| 0| case JOP_TYPECHECK: ------------------ | Branch (5105:13): [True: 0, False: 53.7M] ------------------ 5106| 0| case JOP_JUMP_IF: ------------------ | Branch (5106:13): [True: 0, False: 53.7M] ------------------ 5107| 61.3k| case JOP_JUMP_IF_NOT: ------------------ | Branch (5107:13): [True: 61.3k, False: 53.6M] ------------------ 5108| 61.8k| case JOP_JUMP_IF_NIL: ------------------ | Branch (5108:13): [True: 438, False: 53.7M] ------------------ 5109| 83.4k| case JOP_JUMP_IF_NOT_NIL: ------------------ | Branch (5109:13): [True: 21.6k, False: 53.7M] ------------------ 5110| 105k| case JOP_SET_UPVALUE: ------------------ | Branch (5110:13): [True: 21.6k, False: 53.7M] ------------------ 5111| 105k| nins = 1; 5112| 105k| pin = 1; 5113| 105k| ins[0] = Ia; 5114| 105k| break; 5115| | /* Read D */ 5116| 680| case JOP_ERROR: ------------------ | Branch (5116:13): [True: 680, False: 53.7M] ------------------ 5117| 300k| case JOP_RETURN: ------------------ | Branch (5117:13): [True: 300k, False: 53.4M] ------------------ 5118| 393k| case JOP_PUSH: ------------------ | Branch (5118:13): [True: 92.6k, False: 53.6M] ------------------ 5119| 508k| case JOP_PUSH_ARRAY: ------------------ | Branch (5119:13): [True: 114k, False: 53.6M] ------------------ 5120| 529k| case JOP_TAILCALL: ------------------ | Branch (5120:13): [True: 21.7k, False: 53.7M] ------------------ 5121| 529k| pin = 1; 5122| 529k| nins = 1; 5123| 529k| ins[0] = Id; 5124| 529k| break; 5125| 666| case JOP_PUT: ------------------ | Branch (5125:13): [True: 666, False: 53.7M] ------------------ 5126| 536k| case JOP_PUSH_3: ------------------ | Branch (5126:13): [True: 535k, False: 53.2M] ------------------ 5127| 536k| nins = 3; 5128| 536k| pin = 1; 5129| 536k| ins[0] = Ia; 5130| 536k| ins[1] = Ib; 5131| 536k| ins[2] = Ic; 5132| 536k| break; 5133| | /* Write A */ 5134| 6| case JOP_MAKE_ARRAY: ------------------ | Branch (5134:13): [True: 6, False: 53.7M] ------------------ 5135| 28| case JOP_MAKE_BUFFER: ------------------ | Branch (5135:13): [True: 22, False: 53.7M] ------------------ 5136| 28| case JOP_MAKE_STRING: ------------------ | Branch (5136:13): [True: 0, False: 53.7M] ------------------ 5137| 54| case JOP_MAKE_STRUCT: ------------------ | Branch (5137:13): [True: 26, False: 53.7M] ------------------ 5138| 1.26k| case JOP_MAKE_TABLE: ------------------ | Branch (5138:13): [True: 1.21k, False: 53.7M] ------------------ 5139| 10.4M| case JOP_MAKE_TUPLE: ------------------ | Branch (5139:13): [True: 10.4M, False: 43.2M] ------------------ 5140| 10.4M| case JOP_MAKE_BRACKET_TUPLE: ------------------ | Branch (5140:13): [True: 1.15k, False: 53.7M] ------------------ 5141| 10.4M| out = Ia; 5142| 10.4M| pin = 1; /* TODO - we need an instruction (or psuedo instruction) that can clear the stack but do nothing */ 5143| 10.4M| break; 5144| 1.61M| case JOP_LOAD_INTEGER: ------------------ | Branch (5144:13): [True: 1.61M, False: 52.1M] ------------------ 5145| 13.3M| case JOP_LOAD_CONSTANT: ------------------ | Branch (5145:13): [True: 11.7M, False: 41.9M] ------------------ 5146| 13.4M| case JOP_LOAD_UPVALUE: ------------------ | Branch (5146:13): [True: 84.4k, False: 53.6M] ------------------ 5147| 13.6M| case JOP_CLOSURE: ------------------ | Branch (5147:13): [True: 168k, False: 53.5M] ------------------ 5148| 13.6M| out = Ia; 5149| 13.6M| break; 5150| | /* Read A, B */ 5151| 5.46k| case JOP_PUT_INDEX: ------------------ | Branch (5151:13): [True: 5.46k, False: 53.7M] ------------------ 5152| 5.46k| nins = 2; 5153| 5.46k| ins[0] = Ia; 5154| 5.46k| ins[1] = Ib; 5155| 5.46k| pin = 1; 5156| 5.46k| break; 5157| | /* Read A, E */ 5158| 10.7M| case JOP_PUSH_2: ------------------ | Branch (5158:13): [True: 10.7M, False: 43.0M] ------------------ 5159| 10.7M| nins = 2; 5160| 10.7M| ins[0] = Ia; 5161| 10.7M| ins[1] = Ie; 5162| 10.7M| pin = 1; 5163| 10.7M| break; 5164| | /* A = B op C */ 5165| 0| case JOP_PROPAGATE: ------------------ | Branch (5165:13): [True: 0, False: 53.7M] ------------------ 5166| 424| case JOP_RESUME: ------------------ | Branch (5166:13): [True: 424, False: 53.7M] ------------------ 5167| 424| case JOP_CANCEL: ------------------ | Branch (5167:13): [True: 0, False: 53.7M] ------------------ 5168| 26.9k| case JOP_NEXT: ------------------ | Branch (5168:13): [True: 26.5k, False: 53.7M] ------------------ 5169| 26.9k| pin = 1; 5170| 26.9k| out = Ia; 5171| 26.9k| nins = 2; 5172| 26.9k| ins[0] = Ib; 5173| 26.9k| ins[1] = Ic; 5174| 26.9k| break; 5175| | 5176| | /* No side effects below, can remove. 5177| | * Some of these instructions may have side effects if 5178| | * the inputs are abstracts. */ 5179| | 5180| | /* Loads that write D */ 5181| 1.96M| case JOP_LOAD_NIL: ------------------ | Branch (5181:13): [True: 1.96M, False: 51.7M] ------------------ 5182| 1.96M| case JOP_LOAD_TRUE: ------------------ | Branch (5182:13): [True: 1.16k, False: 53.7M] ------------------ 5183| 1.96M| case JOP_LOAD_FALSE: ------------------ | Branch (5183:13): [True: 324, False: 53.7M] ------------------ 5184| 1.98M| case JOP_LOAD_SELF: ------------------ | Branch (5184:13): [True: 23.2k, False: 53.7M] ------------------ 5185| 1.98M| out = Id; 5186| 1.98M| break; 5187| | 5188| | /* Moves and similar */ 5189| 5.69M| case JOP_MOVE_FAR: ------------------ | Branch (5189:13): [True: 5.69M, False: 48.0M] ------------------ 5190| 5.69M| out = Ie; 5191| 5.69M| nins = 1; 5192| 5.69M| ins[0] = Ia; 5193| 5.69M| break; 5194| 5.43M| case JOP_MOVE_NEAR: ------------------ | Branch (5194:13): [True: 5.43M, False: 48.3M] ------------------ 5195| 5.43M| case JOP_LENGTH: ------------------ | Branch (5195:13): [True: 0, False: 53.7M] ------------------ 5196| 5.43M| case JOP_BNOT: ------------------ | Branch (5196:13): [True: 0, False: 53.7M] ------------------ 5197| 5.43M| out = Ia; 5198| 5.43M| nins = 1; 5199| 5.43M| ins[0] = Ie; 5200| 5.43M| break; 5201| | 5202| | /* A = B op C */ 5203| 0| case JOP_BAND: ------------------ | Branch (5203:13): [True: 0, False: 53.7M] ------------------ 5204| 0| case JOP_BOR: ------------------ | Branch (5204:13): [True: 0, False: 53.7M] ------------------ 5205| 0| case JOP_BXOR: ------------------ | Branch (5205:13): [True: 0, False: 53.7M] ------------------ 5206| 50| case JOP_ADD: ------------------ | Branch (5206:13): [True: 50, False: 53.7M] ------------------ 5207| 50| case JOP_SUBTRACT: ------------------ | Branch (5207:13): [True: 0, False: 53.7M] ------------------ 5208| 70| case JOP_MULTIPLY: ------------------ | Branch (5208:13): [True: 20, False: 53.7M] ------------------ 5209| 126| case JOP_DIVIDE: ------------------ | Branch (5209:13): [True: 56, False: 53.7M] ------------------ 5210| 126| case JOP_DIVIDE_FLOOR: ------------------ | Branch (5210:13): [True: 0, False: 53.7M] ------------------ 5211| 126| case JOP_MODULO: ------------------ | Branch (5211:13): [True: 0, False: 53.7M] ------------------ 5212| 26.4k| case JOP_REMAINDER: ------------------ | Branch (5212:13): [True: 26.3k, False: 53.7M] ------------------ 5213| 26.4k| case JOP_SHIFT_LEFT: ------------------ | Branch (5213:13): [True: 0, False: 53.7M] ------------------ 5214| 26.4k| case JOP_SHIFT_RIGHT: ------------------ | Branch (5214:13): [True: 0, False: 53.7M] ------------------ 5215| 26.4k| case JOP_SHIFT_RIGHT_UNSIGNED: ------------------ | Branch (5215:13): [True: 0, False: 53.7M] ------------------ 5216| 26.4k| case JOP_GREATER_THAN: ------------------ | Branch (5216:13): [True: 0, False: 53.7M] ------------------ 5217| 27.2k| case JOP_LESS_THAN: ------------------ | Branch (5217:13): [True: 780, False: 53.7M] ------------------ 5218| 88.8k| case JOP_EQUALS: ------------------ | Branch (5218:13): [True: 61.6k, False: 53.6M] ------------------ 5219| 88.8k| case JOP_COMPARE: ------------------ | Branch (5219:13): [True: 0, False: 53.7M] ------------------ 5220| 91.3k| case JOP_IN: ------------------ | Branch (5220:13): [True: 2.50k, False: 53.7M] ------------------ 5221| 91.3k| case JOP_GET: ------------------ | Branch (5221:13): [True: 10, False: 53.7M] ------------------ 5222| 91.3k| case JOP_GREATER_THAN_EQUAL: ------------------ | Branch (5222:13): [True: 0, False: 53.7M] ------------------ 5223| 91.3k| case JOP_LESS_THAN_EQUAL: ------------------ | Branch (5223:13): [True: 0, False: 53.7M] ------------------ 5224| 91.8k| case JOP_NOT_EQUALS: ------------------ | Branch (5224:13): [True: 414, False: 53.7M] ------------------ 5225| 91.8k| out = Ia; 5226| 91.8k| nins = 2; 5227| 91.8k| ins[0] = Ib; 5228| 91.8k| ins[1] = Ic; 5229| 91.8k| break; 5230| | 5231| | /* A = op B imm */ 5232| 406| case JOP_ADD_IMMEDIATE: ------------------ | Branch (5232:13): [True: 406, False: 53.7M] ------------------ 5233| 1.51k| case JOP_SUBTRACT_IMMEDIATE: ------------------ | Branch (5233:13): [True: 1.11k, False: 53.7M] ------------------ 5234| 1.52k| case JOP_MULTIPLY_IMMEDIATE: ------------------ | Branch (5234:13): [True: 6, False: 53.7M] ------------------ 5235| 1.52k| case JOP_DIVIDE_IMMEDIATE: ------------------ | Branch (5235:13): [True: 0, False: 53.7M] ------------------ 5236| 1.52k| case JOP_SHIFT_LEFT_IMMEDIATE: ------------------ | Branch (5236:13): [True: 0, False: 53.7M] ------------------ 5237| 1.52k| case JOP_SHIFT_RIGHT_IMMEDIATE: ------------------ | Branch (5237:13): [True: 0, False: 53.7M] ------------------ 5238| 1.52k| case JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE: ------------------ | Branch (5238:13): [True: 0, False: 53.7M] ------------------ 5239| 1.52k| case JOP_GREATER_THAN_IMMEDIATE: ------------------ | Branch (5239:13): [True: 0, False: 53.7M] ------------------ 5240| 1.52k| case JOP_LESS_THAN_IMMEDIATE: ------------------ | Branch (5240:13): [True: 0, False: 53.7M] ------------------ 5241| 1.52k| case JOP_EQUALS_IMMEDIATE: ------------------ | Branch (5241:13): [True: 0, False: 53.7M] ------------------ 5242| 1.52k| case JOP_NOT_EQUALS_IMMEDIATE: ------------------ | Branch (5242:13): [True: 0, False: 53.7M] ------------------ 5243| 4.25M| case JOP_GET_INDEX: ------------------ | Branch (5243:13): [True: 4.25M, False: 49.4M] ------------------ 5244| 4.25M| out = Ia; 5245| 4.25M| nins = 1; 5246| 4.25M| ins[0] = Ib; 5247| 4.25M| break; 5248| 53.7M| } 5249| | /* Test and set output bit in bitmap. If already set, change to noop. */ 5250| | /* Add check to avoid messing with upvalues */ 5251| 53.7M| if (mode == 0) { ------------------ | Branch (5251:13): [True: 26.8M, False: 26.8M] ------------------ 5252| 26.8M| if (out != -1) { ------------------ | Branch (5252:17): [True: 20.9M, False: 5.94M] ------------------ 5253| 20.9M| if (!pin && bs_read_bit(bitset, out) && ------------------ | Branch (5253:21): [True: 15.5M, False: 5.37M] | Branch (5253:29): [True: 1.87M, False: 13.6M] ------------------ 5254| 1.87M| (!def->closure_bitset || !bs_read_bit(def->closure_bitset, out))) { ------------------ | Branch (5254:26): [True: 98.8k, False: 1.77M] | Branch (5254:50): [True: 1.75M, False: 15.7k] ------------------ 5255| 1.85M| def->bytecode[i] = JOP_NOOP; 5256| 1.85M| } 5257| 20.9M| bs_set_bit(bitset, out); 5258| 20.9M| } 5259| | /* Clear input slots from bitmap */ 5260| 46.6M| for (int j = 0; j < nins; j++) { ------------------ | Branch (5260:29): [True: 19.7M, False: 26.8M] ------------------ 5261| 19.7M| bs_clear_bit(bitset, ins[j]); 5262| 19.7M| } 5263| 26.8M| } else if (mode == 1) { ------------------ | Branch (5263:20): [True: 26.8M, False: 0] ------------------ 5264| | /* Clear writes, set reads (in that order!) */ 5265| 26.8M| if (out != -1) bs_clear_bit(bitset, out); ------------------ | Branch (5265:17): [True: 20.9M, False: 5.94M] ------------------ 5266| 46.6M| for (int j = 0; j < nins; j++) { ------------------ | Branch (5266:29): [True: 19.7M, False: 26.8M] ------------------ 5267| 19.7M| janet_assert(ins[j] < def->slotcount, "slot too big"); ------------------ | | 389| 19.7M|#define janet_assert(c, m) do { \ | | 390| 19.7M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 19.7M] | | ------------------ | | 391| 19.7M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 19.7M] | | ------------------ ------------------ 5268| 19.7M| bs_set_bit(bitset, ins[j]); 5269| 19.7M| } 5270| 26.8M| } 5271| 53.7M| } 5272| 430k|} janet.c:bs_clear_bit: 3915| 40.7M|static void bs_clear_bit(uint32_t *bitset, int32_t index) { 3916| 40.7M| bitset[bs_indx(index)] &= ~(bs_mask(index)); 3917| 40.7M|} janet.c:janet_bytecode_basic_blocks: 4062| 161k|static BytecodeBB *janet_bytecode_basic_blocks(JanetFuncDef *def, int32_t *n_blocks) { 4063| 161k| uint32_t *code = def->bytecode; 4064| 161k| int32_t *codes = (int32_t *)code; 4065| | /* Allocate array of blocks to return */ 4066| 161k| uint32_t *bitmap = janet_bytecode_leader_bitmap(def); 4067| 161k| int32_t len = def->bytecode_length; 4068| 161k| int32_t words = ((len - 1) / 32) + 1; 4069| 161k| int32_t block_count = 0; 4070| 1.14M| for (int32_t i = 0; i < words; i++) { ------------------ | Branch (4070:25): [True: 985k, False: 161k] ------------------ 4071| |#ifdef JANET_MSVC 4072| | block_count += __popcnt(bitmap[i]); 4073| |#elif defined(__GNUC__) 4074| | block_count += __builtin_popcount(bitmap[i]); 4075| |#else 4076| | for (int j = 0; j < 32; j++) { 4077| | uint32_t mask = ((uint32_t)1 << j); 4078| | if (mask & bitmap[i]) block_count++; 4079| | } 4080| |#endif 4081| 985k| } 4082| 161k| BytecodeBB *blocks = array_allocate(sizeof(BytecodeBB), block_count); 4083| 161k| int32_t next_block_i = 0; 4084| 161k| int32_t pc = 0; 4085| 376k| while (pc < len) { ------------------ | Branch (4085:12): [True: 215k, False: 161k] ------------------ 4086| 215k| BytecodeBB bb; 4087| 215k| bb.start = pc; 4088| 215k| uint32_t done; 4089| 26.8M| do { 4090| 26.8M| pc++; 4091| 26.8M| done = (pc >= len) || (bitmap[pc >> 5] & (((uint32_t)1) << (pc & 0x1F))); ------------------ | Branch (4091:20): [True: 161k, False: 26.7M] | Branch (4091:35): [True: 53.8k, False: 26.6M] ------------------ 4092| 26.8M| } while (!done); ------------------ | Branch (4092:18): [True: 26.6M, False: 215k] ------------------ 4093| 215k| janet_assert(pc <= len, "bad block end"); ------------------ | | 389| 215k|#define janet_assert(c, m) do { \ | | 390| 215k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 215k] | | ------------------ | | 391| 215k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 215k] | | ------------------ ------------------ 4094| 215k| bb.end = pc; 4095| 215k| bb.next[0] = -1; 4096| 215k| bb.next[1] = -1; 4097| 215k| blocks[next_block_i++] = bb; 4098| 215k| } 4099| 161k| janet_assert(next_block_i == block_count, "bad block count"); ------------------ | | 389| 161k|#define janet_assert(c, m) do { \ | | 390| 161k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 161k] | | ------------------ | | 391| 161k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 161k] | | ------------------ ------------------ 4100| | /* add forward cfg edges */ 4101| 376k| for (int32_t i = 0; i < block_count; i++) { ------------------ | Branch (4101:25): [True: 215k, False: 161k] ------------------ 4102| 215k| int32_t target; 4103| 215k| janet_assert(blocks[i].end > blocks[i].start, "degenerate block start >= end"); ------------------ | | 389| 215k|#define janet_assert(c, m) do { \ | | 390| 215k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 215k] | | ------------------ | | 391| 215k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 215k] | | ------------------ ------------------ 4104| 215k| int32_t lastpc = blocks[i].end - 1; 4105| 215k| switch (code[lastpc] & 0x7F) { 4106| 801| default: ------------------ | Branch (4106:13): [True: 801, False: 214k] ------------------ 4107| 801| blocks[i].next[0] = i + 1; /* blocks sorted by increasing start */ 4108| 801| continue; 4109| 340| case JOP_ERROR: ------------------ | Branch (4109:13): [True: 340, False: 215k] ------------------ 4110| 150k| case JOP_RETURN: ------------------ | Branch (4110:13): [True: 150k, False: 65.3k] ------------------ 4111| 161k| case JOP_RETURN_NIL: ------------------ | Branch (4111:13): [True: 11.3k, False: 204k] ------------------ 4112| 172k| case JOP_TAILCALL: ------------------ | Branch (4112:13): [True: 10.8k, False: 204k] ------------------ 4113| 172k| continue; 4114| 0| case JOP_JUMP_IF: ------------------ | Branch (4114:13): [True: 0, False: 215k] ------------------ 4115| 219| case JOP_JUMP_IF_NIL: ------------------ | Branch (4115:13): [True: 219, False: 215k] ------------------ 4116| 30.9k| case JOP_JUMP_IF_NOT: ------------------ | Branch (4116:13): [True: 30.6k, False: 184k] ------------------ 4117| 41.7k| case JOP_JUMP_IF_NOT_NIL: ------------------ | Branch (4117:13): [True: 10.8k, False: 204k] ------------------ 4118| 41.7k| blocks[i].next[1] = i + 1; /* blocks sorted by increasing start */ 4119| 41.7k| target = lastpc + (codes[lastpc] >> 16); 4120| 41.7k| break; 4121| 219| case JOP_JUMP: ------------------ | Branch (4121:13): [True: 219, False: 215k] ------------------ 4122| 219| target = lastpc + (codes[lastpc] >> 8); 4123| 219| break; 4124| 215k| } 4125| | /* Find block whose start = target */ 4126| 41.9k| int32_t j; 4127| 156M| for (j = 0; j < block_count; j++) { ------------------ | Branch (4127:21): [True: 156M, False: 0] ------------------ 4128| 156M| if (blocks[j].start == target) { ------------------ | Branch (4128:17): [True: 41.9k, False: 156M] ------------------ 4129| 41.9k| blocks[i].next[0] = j; 4130| 41.9k| break; 4131| 41.9k| } 4132| 156M| } 4133| 41.9k| janet_assert(j < block_count, "did not find next block"); ------------------ | | 389| 41.9k|#define janet_assert(c, m) do { \ | | 390| 41.9k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 41.9k] | | ------------------ | | 391| 41.9k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 41.9k] | | ------------------ ------------------ 4134| 41.9k| } 4135| 161k| janet_free(bitmap); ------------------ | | 2415| 161k|#define janet_free(X) free((X)) ------------------ 4136| 161k| *n_blocks = block_count; 4137| 161k| return blocks; 4138| 161k|} janet.c:janet_bytecode_leader_bitmap: 4021| 161k|static uint32_t *janet_bytecode_leader_bitmap(JanetFuncDef *def) { 4022| 161k| uint32_t *code = def->bytecode; 4023| 161k| int32_t *codes = (int32_t *)code; 4024| 161k| int32_t len = def->bytecode_length; 4025| 161k| int32_t words = ((len - 1) / 32) + 1; 4026| 161k| uint32_t *leaders = array_allocate(sizeof(uint32_t), words); 4027| 161k| janet_assert(words >= 0, "bad len"); ------------------ | | 389| 161k|#define janet_assert(c, m) do { \ | | 390| 161k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 161k] | | ------------------ | | 391| 161k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 161k] | | ------------------ ------------------ 4028| 161k| memset(leaders, 0, (size_t) words * sizeof(uint32_t)); 4029| 161k| int did_jump = 1; /* pc=0 is a leader */ 4030| 161k| uint32_t target = 0; 4031| 27.0M| for (int32_t pc = 0; pc < len; pc++) { ------------------ | Branch (4031:26): [True: 26.8M, False: 161k] ------------------ 4032| 26.8M| if (did_jump) bs_set_bit(leaders, pc); ------------------ | Branch (4032:13): [True: 214k, False: 26.6M] ------------------ 4033| 26.8M| did_jump = 0; 4034| 26.8M| switch (code[pc] & 0x7F) { 4035| 26.6M| default: ------------------ | Branch (4035:13): [True: 26.6M, False: 214k] ------------------ 4036| 26.6M| continue; 4037| 26.6M| case JOP_RETURN_NIL: ------------------ | Branch (4037:13): [True: 11.3k, False: 26.8M] ------------------ 4038| 161k| case JOP_RETURN: ------------------ | Branch (4038:13): [True: 150k, False: 26.7M] ------------------ 4039| 161k| case JOP_ERROR: ------------------ | Branch (4039:13): [True: 340, False: 26.8M] ------------------ 4040| 172k| case JOP_TAILCALL: ------------------ | Branch (4040:13): [True: 10.8k, False: 26.8M] ------------------ 4041| 172k| did_jump = 1; 4042| 172k| continue; 4043| 219| case JOP_JUMP: ------------------ | Branch (4043:13): [True: 219, False: 26.8M] ------------------ 4044| 219| target = pc + (codes[pc] >> 8); 4045| 219| bs_set_bit(leaders, target); 4046| 219| did_jump = 1; 4047| 219| continue; 4048| 0| case JOP_JUMP_IF: ------------------ | Branch (4048:13): [True: 0, False: 26.8M] ------------------ 4049| 219| case JOP_JUMP_IF_NIL: ------------------ | Branch (4049:13): [True: 219, False: 26.8M] ------------------ 4050| 30.9k| case JOP_JUMP_IF_NOT: ------------------ | Branch (4050:13): [True: 30.6k, False: 26.8M] ------------------ 4051| 41.7k| case JOP_JUMP_IF_NOT_NIL: ------------------ | Branch (4051:13): [True: 10.8k, False: 26.8M] ------------------ 4052| 41.7k| target = pc + (codes[pc] >> 16); 4053| 41.7k| bs_set_bit(leaders, target); 4054| 41.7k| did_jump = 1; 4055| 41.7k| continue; 4056| 26.8M| } 4057| 26.8M| } 4058| 161k| return leaders; 4059| 161k|} janet.c:janet_strlike_cmp: 6108| 186k|static int janet_strlike_cmp(JanetType type, Janet x, const char *cstring) { 6109| 186k| if (janet_type(x) != type) return 0; ------------------ | | 795| 186k| (isnan((x).number) \ | | 796| 186k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 186k| : JANET_NUMBER) ------------------ | Branch (6109:9): [True: 186k, False: 211] | Branch (6109:9): [True: 179k, False: 7.62k] ------------------ 6110| 7.62k| return !janet_cstrcmp(janet_unwrap_string(x), cstring); ------------------ | | 863| 7.62k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 6111| 186k|} janet.c:maxarity1: 6518| 8|static int maxarity1(JanetFopts opts, JanetSlot *args) { 6519| 8| (void) opts; 6520| | return janet_v_count(args) <= 1; ------------------ | | 759| 8|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 6|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 6|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 6, False: 2] | | ------------------ ------------------ 6521| 8|} janet.c:do_debug: 6636| 6|static JanetSlot do_debug(JanetFopts opts, JanetSlot *args) { 6637| 6| (void)args; 6638| 6| int32_t len = janet_v_count(args); ------------------ | | 759| 6|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 4|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 4|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 4, False: 2] | | ------------------ ------------------ 6639| 6| JanetSlot t = janetc_gettarget(opts); 6640| 6| janetc_emit_ssu(opts.compiler, JOP_SIGNAL, t, 6641| 6| (len == 1) ? args[0] : janetc_cslot(janet_wrap_nil()), ------------------ | | 831| 2|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6641:21): [True: 4, False: 2] ------------------ 6642| 6| JANET_SIGNAL_DEBUG, 6643| 6| 1); 6644| 6| return t; 6645| 6|} janet.c:fixarity1: 6514| 203|static int fixarity1(JanetFopts opts, JanetSlot *args) { 6515| 203| (void) opts; 6516| | return janet_v_count(args) == 1; ------------------ | | 759| 203|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 203|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 203|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 203, False: 0] | | ------------------ ------------------ 6517| 203|} janet.c:do_error: 6632| 170|static JanetSlot do_error(JanetFopts opts, JanetSlot *args) { 6633| 170| janetc_emit_s(opts.compiler, JOP_ERROR, args[0], 0); 6634| 170| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 170|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 170| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 170|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 170|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6635| 170|} janet.c:minarity2: 6522| 183k|static int minarity2(JanetFopts opts, JanetSlot *args) { 6523| 183k| (void) opts; 6524| | return janet_v_count(args) >= 2; ------------------ | | 759| 183k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 183k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 183k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 183k, False: 0] | | ------------------ ------------------ 6525| 183k|} janet.c:do_apply: 6718| 183k|static JanetSlot do_apply(JanetFopts opts, JanetSlot *args) { 6719| | /* Push phase */ 6720| 183k| JanetCompiler *c = opts.compiler; 6721| 183k| int32_t i; 6722| 183k| for (i = 1; i < janet_v_count(args) - 3; i += 3) ------------------ | | 759| 183k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 183k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 183k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 183k, False: 0] | | ------------------ ------------------ | Branch (6722:17): [True: 0, False: 183k] ------------------ 6723| 0| janetc_emit_sss(c, JOP_PUSH_3, args[i], args[i + 1], args[i + 2], 0); 6724| 183k| if (i == janet_v_count(args) - 3) ------------------ | | 759| 183k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 183k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 183k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 183k, False: 0] | | ------------------ ------------------ | Branch (6724:9): [True: 0, False: 183k] ------------------ 6725| 0| janetc_emit_ss(c, JOP_PUSH_2, args[i], args[i + 1], 0); 6726| 183k| else if (i == janet_v_count(args) - 2) ------------------ | | 759| 183k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 183k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 183k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 183k, False: 0] | | ------------------ ------------------ | Branch (6726:14): [True: 0, False: 183k] ------------------ 6727| 0| janetc_emit_s(c, JOP_PUSH, args[i], 0); 6728| | /* Push array phase */ 6729| 183k| janetc_emit_s(c, JOP_PUSH_ARRAY, janet_v_last(args), 0); ------------------ | | 760| 183k|#define janet_v_last(v) ((v)[janet_v__cnt(v) - 1]) | | ------------------ | | | | 766| 183k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 183k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 6730| | /* Call phase */ 6731| 183k| JanetSlot target; 6732| 183k| if (opts.flags & JANET_FOPTS_TAIL) { ------------------ | | 1147| 183k|#define JANET_FOPTS_TAIL 0x10000 ------------------ | Branch (6732:9): [True: 0, False: 183k] ------------------ 6733| 0| janetc_emit_s(c, JOP_TAILCALL, args[0], 0); 6734| 0| target = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6735| 0| target.flags |= JANET_SLOT_RETURNED; ------------------ | | 1042| 0|#define JANET_SLOT_RETURNED 0x100000 ------------------ 6736| 183k| } else { 6737| 183k| target = janetc_gettarget(opts); 6738| 183k| janetc_emit_ss(c, JOP_CALL, target, args[0], 1); 6739| 183k| } 6740| 183k| return target; 6741| 183k|} janet.c:arity1or2: 6504| 2.31k|static int arity1or2(JanetFopts opts, JanetSlot *args) { 6505| 2.31k| (void) opts; 6506| 2.31k| int32_t arity = janet_v_count(args); ------------------ | | 759| 2.31k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.31k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.31k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.31k, False: 0] | | ------------------ ------------------ 6507| 2.31k| return arity == 1 || arity == 2; ------------------ | Branch (6507:12): [True: 254, False: 2.06k] | Branch (6507:26): [True: 2.06k, False: 0] ------------------ 6508| 2.31k|} janet.c:do_resume: 6712| 254|static JanetSlot do_resume(JanetFopts opts, JanetSlot *args) { 6713| 254| return opfunction(opts, args, JOP_RESUME, janet_wrap_nil()); ------------------ | | 831| 254|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 254| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 254|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 254|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6714| 254|} janet.c:opfunction: 6554| 2.31k| Janet defaultArg2) { 6555| 2.31k| JanetCompiler *c = opts.compiler; 6556| 2.31k| int32_t len; 6557| 2.31k| len = janet_v_count(args); ------------------ | | 759| 2.31k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.31k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.31k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.31k, False: 0] | | ------------------ ------------------ 6558| 2.31k| JanetSlot t; 6559| 2.31k| if (len == 1) { ------------------ | Branch (6559:9): [True: 254, False: 2.06k] ------------------ 6560| 254| t = janetc_gettarget(opts); 6561| 254| janetc_emit_sss(c, op, t, args[0], janetc_cslot(defaultArg2), 1); 6562| 254| return t; 6563| 2.06k| } else { 6564| | /* len == 2 */ 6565| 2.06k| t = janetc_gettarget(opts); 6566| 2.06k| janetc_emit_sss(c, op, t, args[0], args[1], 1); 6567| 2.06k| } 6568| 2.06k| return t; 6569| 2.31k|} janet.c:fixarity2: 6526| 1.05k|static int fixarity2(JanetFopts opts, JanetSlot *args) { 6527| 1.05k| (void) opts; 6528| | return janet_v_count(args) == 2; ------------------ | | 759| 1.05k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.05k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.05k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.05k, False: 0] | | ------------------ ------------------ 6529| 1.05k|} janet.c:do_in: 6646| 1.01k|static JanetSlot do_in(JanetFopts opts, JanetSlot *args) { 6647| 1.01k| return opreduce(opts, args, JOP_IN, 0, janet_wrap_nil(), janet_wrap_nil()); ------------------ | | 831| 1.01k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.01k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.01k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.01k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return opreduce(opts, args, JOP_IN, 0, janet_wrap_nil(), janet_wrap_nil()); ------------------ | | 831| 1.01k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.01k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.01k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.01k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6648| 1.01k|} janet.c:opreduce: 6593| 3.08k| Janet unary) { 6594| 3.08k| JanetCompiler *c = opts.compiler; 6595| 3.08k| int32_t i, len; 6596| 3.08k| int8_t imm = 0; 6597| 3.08k| len = janet_v_count(args); ------------------ | | 759| 3.08k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3.08k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.08k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3.08k, False: 5] | | ------------------ ------------------ 6598| 3.08k| JanetSlot t; 6599| 3.08k| if (len == 0) { ------------------ | Branch (6599:9): [True: 5, False: 3.08k] ------------------ 6600| 5| return janetc_cslot(nullary); 6601| 3.08k| } else if (len == 1) { ------------------ | Branch (6601:16): [True: 27, False: 3.05k] ------------------ 6602| 27| t = janetc_gettarget(opts); 6603| | /* Special case subtract to be times -1 */ 6604| 27| if (op == JOP_SUBTRACT) { ------------------ | Branch (6604:13): [True: 5, False: 22] ------------------ 6605| 5| janetc_emit_ssi(c, JOP_MULTIPLY_IMMEDIATE, t, args[0], -1, 1); 6606| 22| } else { 6607| 22| janetc_emit_sss(c, op, t, janetc_cslot(unary), args[0], 1); 6608| 22| } 6609| 27| return t; 6610| 27| } 6611| 3.05k| t = janetc_gettarget(opts); 6612| 3.05k| if (opim && can_slot_be_imm(args[1], &imm)) { ------------------ | Branch (6612:9): [True: 695, False: 2.36k] | Branch (6612:17): [True: 656, False: 39] ------------------ 6613| 656| janetc_emit_ssi(c, opim, t, args[0], imm, 1); 6614| 2.40k| } else { 6615| 2.40k| janetc_emit_sss(c, op, t, args[0], args[1], 1); 6616| 2.40k| } 6617| 15.2k| for (i = 2; i < len; i++) { ------------------ | Branch (6617:17): [True: 12.2k, False: 3.05k] ------------------ 6618| 12.2k| if (opim && can_slot_be_imm(args[i], &imm)) { ------------------ | Branch (6618:13): [True: 173, False: 12.0k] | Branch (6618:21): [True: 101, False: 72] ------------------ 6619| 101| janetc_emit_ssi(c, opim, t, t, imm, 1); 6620| 12.1k| } else { 6621| 12.1k| janetc_emit_sss(c, op, t, t, args[i], 1); 6622| 12.1k| } 6623| 12.2k| } 6624| 3.05k| return t; 6625| 3.08k|} janet.c:can_slot_be_imm: 6581| 70.7k|static int can_slot_be_imm(JanetSlot s, int8_t *out) { 6582| 70.7k| if (!(s.flags & JANET_SLOT_CONSTANT)) return 0; ------------------ | | 1038| 70.7k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (6582:9): [True: 28.3k, False: 42.3k] ------------------ 6583| 42.3k| return can_be_imm(s.constant, out); 6584| 70.7k|} janet.c:can_be_imm: 6572| 42.3k|static int can_be_imm(Janet x, int8_t *out) { 6573| 42.3k| if (!janet_checkint(x)) return 0; ------------------ | Branch (6573:9): [True: 41.4k, False: 949] ------------------ 6574| 949| int32_t integer = janet_unwrap_integer(x); ------------------ | | 966| 949|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 949|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 6575| 949| if (integer > INT8_MAX || integer < INT8_MIN) return 0; ------------------ | Branch (6575:9): [True: 16, False: 933] | Branch (6575:31): [True: 14, False: 919] ------------------ 6576| 919| *out = (int8_t) integer; 6577| 919| return 1; 6578| 949|} janet.c:do_add: 6745| 132|static JanetSlot do_add(JanetFopts opts, JanetSlot *args) { 6746| 132| return opreduce(opts, args, JOP_ADD, JOP_ADD_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0)); ------------------ | | 967| 132|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 132|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ return opreduce(opts, args, JOP_ADD, JOP_ADD_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0)); ------------------ | | 967| 132|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 132|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 6747| 132|} janet.c:do_sub: 6748| 562|static JanetSlot do_sub(JanetFopts opts, JanetSlot *args) { 6749| 562| return opreduce(opts, args, JOP_SUBTRACT, JOP_SUBTRACT_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0)); ------------------ | | 967| 562|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 562|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ return opreduce(opts, args, JOP_SUBTRACT, JOP_SUBTRACT_IMMEDIATE, janet_wrap_integer(0), janet_wrap_integer(0)); ------------------ | | 967| 562|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 562|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 6750| 562|} janet.c:do_mul: 6751| 5|static JanetSlot do_mul(JanetFopts opts, JanetSlot *args) { 6752| 5| return opreduce(opts, args, JOP_MULTIPLY, JOP_MULTIPLY_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); ------------------ | | 967| 5|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 5|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ return opreduce(opts, args, JOP_MULTIPLY, JOP_MULTIPLY_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); ------------------ | | 967| 5|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 5|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 6753| 5|} janet.c:do_div: 6754| 28|static JanetSlot do_div(JanetFopts opts, JanetSlot *args) { 6755| 28| return opreduce(opts, args, JOP_DIVIDE, JOP_DIVIDE_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); ------------------ | | 967| 28|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 28|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ return opreduce(opts, args, JOP_DIVIDE, JOP_DIVIDE_IMMEDIATE, janet_wrap_integer(1), janet_wrap_integer(1)); ------------------ | | 967| 28|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 28|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 6756| 28|} janet.c:do_gt: 6827| 182|static JanetSlot do_gt(JanetFopts opts, JanetSlot *args) { 6828| 182| return compreduce(opts, args, JOP_GREATER_THAN, JOP_GREATER_THAN_IMMEDIATE, 0); 6829| 182|} janet.c:compreduce: 6794| 1.30k| int invert) { 6795| 1.30k| JanetCompiler *c = opts.compiler; 6796| 1.30k| int32_t i, len; 6797| 1.30k| int8_t imm = 0; 6798| 1.30k| len = janet_v_count(args); ------------------ | | 759| 1.30k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.01k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.01k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.01k, False: 289] | | ------------------ ------------------ 6799| 1.30k| int32_t *labels = NULL; 6800| 1.30k| JanetSlot t; 6801| 1.30k| if (len < 2) { ------------------ | Branch (6801:9): [True: 290, False: 1.01k] ------------------ 6802| 290| return invert ------------------ | Branch (6802:16): [True: 0, False: 290] ------------------ 6803| 290| ? janetc_cslot(janet_wrap_false()) ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6804| 290| : janetc_cslot(janet_wrap_true()); ------------------ | | 832| 290|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 290| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 290|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 290|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6805| 290| } 6806| 1.01k| t = janetc_gettarget(opts); 6807| 70.8k| for (i = 1; i < len; i++) { ------------------ | Branch (6807:17): [True: 69.8k, False: 1.01k] ------------------ 6808| 69.8k| if (opim && can_slot_be_imm(args[i], &imm)) { ------------------ | Branch (6808:13): [True: 69.8k, False: 0] | Branch (6808:21): [True: 162, False: 69.6k] ------------------ 6809| 162| janetc_emit_ssi(c, opim, t, args[i - 1], imm, 1); 6810| 69.6k| } else { 6811| 69.6k| janetc_emit_sss(c, op, t, args[i - 1], args[i], 1); 6812| 69.6k| } 6813| 69.8k| if (i != (len - 1)) { ------------------ | Branch (6813:13): [True: 68.8k, False: 1.01k] ------------------ 6814| 68.8k| int32_t label = janetc_emit_si(c, invert ? JOP_JUMP_IF : JOP_JUMP_IF_NOT, t, 0, 1); ------------------ | Branch (6814:47): [True: 0, False: 68.8k] ------------------ 6815| 68.8k| janet_v_push(labels, label); ------------------ | | 757| 68.8k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 68.8k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 68.8k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 68.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 68.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 68.0k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 68.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 765, False: 68.0k] | | | | | | | Branch (768:50): [True: 4.16k, False: 63.8k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 4.93k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 68.8k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 68.8k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 6816| 68.8k| } 6817| 69.8k| } 6818| 1.01k| int32_t end = janet_v_count(c->buffer); ------------------ | | 759| 1.01k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.01k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.01k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.01k, False: 0] | | ------------------ ------------------ 6819| 69.8k| for (i = 0; i < janet_v_count(labels); i++) { ------------------ | | 759| 69.8k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 69.5k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 69.5k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 69.5k, False: 252] | | ------------------ ------------------ | Branch (6819:17): [True: 68.8k, False: 1.01k] ------------------ 6820| 68.8k| int32_t label = labels[i]; 6821| 68.8k| c->buffer[label] |= ((uint32_t)(end - label) << 16); 6822| 68.8k| } 6823| | janet_v_free(labels); ------------------ | | 756| 1.01k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 765|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 765, False: 252] | | ------------------ ------------------ 6824| 1.01k| return t; 6825| 1.30k|} janet.c:do_lt: 6830| 4|static JanetSlot do_lt(JanetFopts opts, JanetSlot *args) { 6831| 4| return compreduce(opts, args, JOP_LESS_THAN, JOP_LESS_THAN_IMMEDIATE, 0); 6832| 4|} janet.c:do_eq: 6839| 914|static JanetSlot do_eq(JanetFopts opts, JanetSlot *args) { 6840| 914| return compreduce(opts, args, JOP_EQUALS, JOP_EQUALS_IMMEDIATE, 0); 6841| 914|} janet.c:do_neq: 6842| 207|static JanetSlot do_neq(JanetFopts opts, JanetSlot *args) { 6843| 207| return compreduce(opts, args, JOP_NOT_EQUALS, JOP_NOT_EQUALS_IMMEDIATE, 1); 6844| 207|} janet.c:do_propagate: 6629| 35|static JanetSlot do_propagate(JanetFopts opts, JanetSlot *args) { 6630| 35| return opreduce(opts, args, JOP_PROPAGATE, 0, janet_wrap_nil(), janet_wrap_nil()); ------------------ | | 831| 35|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 35| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 35|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return opreduce(opts, args, JOP_PROPAGATE, 0, janet_wrap_nil(), janet_wrap_nil()); ------------------ | | 831| 35|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 35| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 35|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6631| 35|} janet.c:arity2or3: 6509| 8|static int arity2or3(JanetFopts opts, JanetSlot *args) { 6510| 8| (void) opts; 6511| 8| int32_t arity = janet_v_count(args); ------------------ | | 759| 8|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 8|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 8|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 8, False: 0] | | ------------------ ------------------ 6512| 8| return arity == 2 || arity == 3; ------------------ | Branch (6512:12): [True: 2, False: 6] | Branch (6512:26): [True: 3, False: 3] ------------------ 6513| 8|} janet.c:do_get: 6649| 5|static JanetSlot do_get(JanetFopts opts, JanetSlot *args) { 6650| 5| if (janet_v_count(args) == 3) { ------------------ | | 759| 5|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 5|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 5|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 5, False: 0] | | ------------------ ------------------ | Branch (6650:9): [True: 3, False: 2] ------------------ 6651| 3| JanetCompiler *c = opts.compiler; 6652| 3| JanetSlot t = janetc_gettarget(opts); 6653| 3| int target_is_default = janetc_sequal(t, args[2]); 6654| 3| JanetSlot dflt_slot = args[2]; 6655| 3| if (target_is_default) { ------------------ | Branch (6655:13): [True: 0, False: 3] ------------------ 6656| 0| dflt_slot = janetc_farslot(c); 6657| 0| janetc_copy(c, dflt_slot, t); 6658| 0| } 6659| 3| janetc_emit_sss(c, JOP_GET, t, args[0], args[1], 1); 6660| 3| int32_t label = janetc_emit_si(c, JOP_JUMP_IF_NOT_NIL, t, 0, 0); 6661| 3| janetc_copy(c, t, dflt_slot); 6662| 3| if (target_is_default) janetc_freeslot(c, dflt_slot); ------------------ | Branch (6662:13): [True: 0, False: 3] ------------------ 6663| 3| int32_t current = janet_v_count(c->buffer); ------------------ | | 759| 3|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3, False: 0] | | ------------------ ------------------ 6664| 3| c->buffer[label] |= (uint32_t)(current - label) << 16; 6665| 3| return t; 6666| 3| } else { 6667| 2| return opreduce(opts, args, JOP_GET, 0, janet_wrap_nil(), janet_wrap_nil()); ------------------ | | 831| 2|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return opreduce(opts, args, JOP_GET, 0, janet_wrap_nil(), janet_wrap_nil()); ------------------ | | 831| 2|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6668| 2| } 6669| 5|} janet.c:do_next: 6670| 2.06k|static JanetSlot do_next(JanetFopts opts, JanetSlot *args) { 6671| 2.06k| return opfunction(opts, args, JOP_NEXT, janet_wrap_nil()); ------------------ | | 831| 2.06k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2.06k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2.06k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.06k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6672| 2.06k|} janet.c:do_remainder: 6763| 1.30k|static JanetSlot do_remainder(JanetFopts opts, JanetSlot *args) { 6764| 1.30k| return opreduce(opts, args, JOP_REMAINDER, 0, janet_wrap_integer(0), janet_wrap_integer(1)); ------------------ | | 967| 1.30k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 1.30k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ return opreduce(opts, args, JOP_REMAINDER, 0, janet_wrap_integer(0), janet_wrap_integer(1)); ------------------ | | 967| 1.30k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 1.30k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 6765| 1.30k|} janet.c:macroexpand1: 7809| 2.37M| const JanetSpecial **spec) { 7810| 2.37M| if (!janet_checktype(x, JANET_TUPLE)) ------------------ | | 806| 2.37M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 2.37M] | | ------------------ | | 807| 2.37M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.37M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.37M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.37M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.37M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.37M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7810:9): [True: 1.45M, False: 916k] ------------------ 7811| 1.45M| return 0; 7812| 916k| const Janet *form = janet_unwrap_tuple(x); ------------------ | | 858| 916k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 7813| 916k| if (janet_tuple_length(form) == 0) ------------------ | | 1802| 916k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 916k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (7813:9): [True: 1.81k, False: 914k] ------------------ 7814| 1.81k| return 0; 7815| | /* Source map - only set when we get a tuple */ 7816| 914k| if (janet_tuple_sm_line(form) >= 0) { ------------------ | | 1804| 914k|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 914k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (7816:9): [True: 349k, False: 565k] ------------------ 7817| 349k| c->current_mapping.line = janet_tuple_sm_line(form); ------------------ | | 1804| 349k|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 349k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 7818| 349k| c->current_mapping.column = janet_tuple_sm_column(form); ------------------ | | 1805| 349k|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 349k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 7819| 349k| } 7820| | /* Bracketed tuples are not specials or macros! */ 7821| 914k| if (janet_tuple_flag(form) & JANET_TUPLE_FLAG_BRACKETCTOR) ------------------ | | 1806| 914k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 914k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_flag(form) & JANET_TUPLE_FLAG_BRACKETCTOR) ------------------ | | 1798| 914k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (7821:9): [True: 244, False: 914k] ------------------ 7822| 244| return 0; 7823| 914k| if (!janet_checktype(form[0], JANET_SYMBOL)) ------------------ | | 806| 914k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 914k] | | ------------------ | | 807| 914k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 914k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 914k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 914k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 914k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 914k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7823:9): [True: 188k, False: 725k] ------------------ 7824| 188k| return 0; 7825| 725k| const uint8_t *name = janet_unwrap_symbol(form[0]); ------------------ | | 864| 725k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 7826| 725k| const JanetSpecial *s = janetc_special(name); 7827| 725k| if (s) { ------------------ | Branch (7827:9): [True: 506k, False: 218k] ------------------ 7828| 506k| *spec = s; 7829| 506k| return 0; 7830| 506k| } 7831| 218k| Janet macroval; 7832| 218k| JanetBindingType btype = janet_resolve(c->env, name, ¯oval); 7833| 218k| if (!(btype == JANET_BINDING_MACRO || btype == JANET_BINDING_DYNAMIC_MACRO) || ------------------ | Branch (7833:11): [True: 68.6k, False: 149k] | Branch (7833:43): [True: 0, False: 149k] ------------------ 7834| 68.6k| !janet_checktype(macroval, JANET_FUNCTION)) ------------------ | | 806| 68.6k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 68.6k] | | ------------------ | | 807| 68.6k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 68.6k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 68.6k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 68.6k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7834:13): [True: 0, False: 68.6k] ------------------ 7835| 149k| return 0; 7836| | 7837| | /* Evaluate macro */ 7838| 68.6k| JanetFunction *macro = janet_unwrap_function(macroval); ------------------ | | 868| 68.6k|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 7839| 68.6k| int32_t arity = janet_tuple_length(form) - 1; ------------------ | | 1802| 68.6k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 68.6k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 7840| 68.6k| JanetFiber *fiberp = janet_fiber(macro, 64, arity, form + 1); 7841| 68.6k| if (NULL == fiberp) { ------------------ | Branch (7841:9): [True: 4, False: 68.6k] ------------------ 7842| 4| int32_t minar = macro->def->min_arity; 7843| 4| int32_t maxar = macro->def->max_arity; 7844| 4| const uint8_t *es = NULL; 7845| 4| if (minar >= 0 && arity < minar) ------------------ | Branch (7845:13): [True: 4, False: 0] | Branch (7845:27): [True: 0, False: 4] ------------------ 7846| 0| es = janet_formatc("macro arity mismatch, expected at least %d, got %d", minar, arity); 7847| 4| if (maxar >= 0 && arity > maxar) ------------------ | Branch (7847:13): [True: 4, False: 0] | Branch (7847:27): [True: 4, False: 0] ------------------ 7848| 4| es = janet_formatc("macro arity mismatch, expected at most %d, got %d", maxar, arity); 7849| 4| c->result.macrofiber = NULL; 7850| 4| janetc_error(c, es); 7851| 4| return 0; 7852| 4| } 7853| | /* Set env */ 7854| 68.6k| fiberp->env = c->env; 7855| 68.6k| int lock = janet_gclock(); 7856| 68.6k| Janet mf_kw = janet_ckeywordv("macro-form"); ------------------ | | 1843| 68.6k|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 68.6k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 68.6k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7857| 68.6k| janet_table_put(c->env, mf_kw, x); 7858| 68.6k| Janet ml_kw = janet_ckeywordv("macro-lints"); ------------------ | | 1843| 68.6k|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 68.6k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 68.6k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7859| 68.6k| if (c->lints) { ------------------ | Branch (7859:9): [True: 0, False: 68.6k] ------------------ 7860| 0| janet_table_put(c->env, ml_kw, janet_wrap_array(c->lints)); ------------------ | | 845| 0|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7861| 0| } 7862| 68.6k| Janet tempOut; 7863| 68.6k| JanetSignal status = janet_continue(fiberp, janet_wrap_nil(), &tempOut); ------------------ | | 831| 68.6k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 68.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7864| 68.6k| janet_table_put(c->env, mf_kw, janet_wrap_nil()); ------------------ | | 831| 68.6k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 68.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7865| 68.6k| janet_table_put(c->env, ml_kw, janet_wrap_nil()); ------------------ | | 831| 68.6k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 68.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7866| 68.6k| janet_gcunlock(lock); 7867| 68.6k| if (status != JANET_SIGNAL_OK) { ------------------ | Branch (7867:9): [True: 2.72k, False: 65.9k] ------------------ 7868| 2.72k| const uint8_t *es = janet_formatc("(macro) %V", tempOut); 7869| 2.72k| c->result.macrofiber = fiberp; 7870| 2.72k| janetc_error(c, es); 7871| 2.72k| return 0; 7872| 65.9k| } else { 7873| 65.9k| *out = tempOut; 7874| 65.9k| } 7875| | 7876| 65.9k| return 1; 7877| 68.6k|} janet.c:janetc_tuple: 7779| 244|static JanetSlot janetc_tuple(JanetFopts opts, Janet x) { 7780| 244| JanetCompiler *c = opts.compiler; 7781| 244| const Janet *t = janet_unwrap_tuple(x); ------------------ | | 858| 244|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 7782| 244| return janetc_maker(opts, 7783| | janetc_toslots(c, t, janet_tuple_length(t)), ------------------ | | 1802| 244|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 244|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 7784| 244| JOP_MAKE_TUPLE); 7785| 244|} janet.c:janetc_maker: 7731| 316|static JanetSlot janetc_maker(JanetFopts opts, JanetSlot *slots, int op) { 7732| 316| JanetCompiler *c = opts.compiler; 7733| 316| JanetSlot retslot; 7734| | 7735| | /* Check if this structure is composed entirely of constants */ 7736| 316| int can_inline = 1; 7737| 1.98k| for (int32_t i = 0; i < janet_v_count(slots); i++) { ------------------ | | 759| 1.98k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.97k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.97k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.97k, False: 10] | | ------------------ ------------------ | Branch (7737:25): [True: 1.92k, False: 59] ------------------ 7738| 1.92k| if (!(slots[i].flags & JANET_SLOT_CONSTANT) || ------------------ | | 1038| 1.92k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (7738:13): [True: 257, False: 1.67k] ------------------ 7739| 1.67k| (slots[i].flags & JANET_SLOT_SPLICED)) { ------------------ | | 1046| 1.67k|#define JANET_SLOT_SPLICED 0x1000000 ------------------ | Branch (7739:17): [True: 0, False: 1.67k] ------------------ 7740| 257| can_inline = 0; 7741| 257| break; 7742| 257| } 7743| 1.92k| } 7744| | 7745| 316| if (can_inline && (op == JOP_MAKE_STRUCT)) { ------------------ | Branch (7745:9): [True: 59, False: 257] | Branch (7745:23): [True: 19, False: 40] ------------------ 7746| 19| JanetKV *st = janet_struct_begin(janet_v_count(slots) / 2); ------------------ | | 759| 19|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 10|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 10|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 10, False: 9] | | ------------------ ------------------ 7747| 817| for (int32_t i = 0; i < janet_v_count(slots); i += 2) { ------------------ | | 759| 817|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 808|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 808|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 808, False: 9] | | ------------------ ------------------ | Branch (7747:29): [True: 798, False: 19] ------------------ 7748| 798| Janet k = slots[i].constant; 7749| 798| Janet v = slots[i + 1].constant; 7750| 798| janet_struct_put(st, k, v); 7751| 798| } 7752| 19| retslot = janetc_cslot(janet_wrap_struct(janet_struct_end(st))); ------------------ | | 842| 19|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 19| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 19|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 19|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7753| 19| janetc_freeslots(c, slots); 7754| 297| } else if (can_inline && (op == JOP_MAKE_TUPLE)) { ------------------ | Branch (7754:16): [True: 40, False: 257] | Branch (7754:30): [True: 3, False: 37] ------------------ 7755| 3| Janet *tup = janet_tuple_begin(janet_v_count(slots)); ------------------ | | 759| 3|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3, False: 0] | | ------------------ ------------------ 7756| 7| for (int32_t i = 0; i < janet_v_count(slots); i++) { ------------------ | | 759| 7|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 7|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 7|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 7, False: 0] | | ------------------ ------------------ | Branch (7756:29): [True: 4, False: 3] ------------------ 7757| 4| tup[i] = slots[i].constant; 7758| 4| } 7759| 3| retslot = janetc_cslot(janet_wrap_tuple(janet_tuple_end(tup))); ------------------ | | 843| 3|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 3| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 3|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7760| 3| janetc_freeslots(c, slots); 7761| 294| } else { 7762| 294| janetc_pushslots(c, slots); 7763| 294| janetc_freeslots(c, slots); 7764| 294| retslot = janetc_gettarget(opts); 7765| 294| janetc_emit_s(c, op, retslot, 1); 7766| 294| } 7767| | 7768| 316| return retslot; 7769| 316|} janet.c:janetc_call: 7528| 341k|static JanetSlot janetc_call(JanetFopts opts, JanetSlot *slots, JanetSlot fun, const Janet *form) { 7529| 341k| JanetSlot retslot; 7530| 341k| JanetCompiler *c = opts.compiler; 7531| 341k| int specialized = 0; 7532| 341k| if (fun.flags & JANET_SLOT_CONSTANT && !has_spliced(slots)) { ------------------ | | 1038| 683k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (7532:9): [True: 309k, False: 32.1k] | Branch (7532:44): [True: 309k, False: 148] ------------------ 7533| 309k| if (janet_checktype(fun.constant, JANET_FUNCTION)) { ------------------ | | 806| 309k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 190k, False: 118k] | | | Branch (806:6): [Folded, False: 309k] | | ------------------ | | 807| 309k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 309k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 309k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 309k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 309k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 309k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7534| 190k| JanetFunction *f = janet_unwrap_function(fun.constant); ------------------ | | 868| 190k|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 7535| 190k| const JanetFunOptimizer *o = janetc_funopt(f->def->flags); 7536| 190k| if (o && (!o->can_optimize || o->can_optimize(opts, slots))) { ------------------ | Branch (7536:17): [True: 190k, False: 0] | Branch (7536:23): [True: 3.34k, False: 187k] | Branch (7536:43): [True: 187k, False: 40] ------------------ 7537| 190k| specialized = 1; 7538| 190k| retslot = o->optimize(opts, slots); 7539| 190k| } else if (function_can_inline(opts, f, slots)) { ------------------ | Branch (7539:24): [True: 0, False: 40] ------------------ 7540| | /* Function inlining */ 7541| 0| int is_tail; 7542| 0| JanetSlot target; 7543| 0| if ((opts.flags & JANET_FOPTS_TAIL) && ------------------ | | 1147| 0|#define JANET_FOPTS_TAIL 0x10000 ------------------ | Branch (7543:21): [True: 0, False: 0] ------------------ 7544| | /* Prevent top level tail calls for better errors */ 7545| 0| !(c->scope->flags & JANET_SCOPE_TOP)) { ------------------ | | 1060| 0|#define JANET_SCOPE_TOP 4 ------------------ | Branch (7545:25): [True: 0, False: 0] ------------------ 7546| 0| is_tail = 1; 7547| 0| } else { 7548| 0| is_tail = 0; 7549| 0| } 7550| | /* contiguous chunk of fun->def->slotcount slots */ 7551| 0| if (!is_tail) target = janetc_gettarget(opts); ------------------ | Branch (7551:21): [True: 0, False: 0] ------------------ 7552| 0| int32_t nslots = f->def->slotcount; 7553| 0| int32_t slot_delta = janetc_regalloc_n(&c->scope->ra, nslots); 7554| 0| if (slot_delta + f->def->slotcount < 256) { ------------------ | Branch (7554:21): [True: 0, False: 0] ------------------ 7555| | /*janet_eprintf("inlining %V\n", janet_wrap_function(f));*/ 7556| | /* Limit inlining when too many slots */ 7557| 0| JanetScope *scope = c->scope; 7558| 0| while (scope) { ------------------ | Branch (7558:28): [True: 0, False: 0] ------------------ 7559| 0| if (scope->flags & JANET_SCOPE_FUNCTION) ------------------ | | 1058| 0|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (7559:29): [True: 0, False: 0] ------------------ 7560| 0| break; 7561| 0| scope = scope->parent; 7562| 0| } 7563| | /* Setup the function parameters */ 7564| 0| JanetSlot dest; 7565| 0| dest.envindex = -1; 7566| 0| dest.flags = JANET_SLOTTYPE_ANY; ------------------ | | 1048| 0|#define JANET_SLOTTYPE_ANY 0xFFFF ------------------ 7567| 0| dest.constant = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7568| 0| for (int32_t i = 0; i < janet_v_count(slots); i++) { ------------------ | | 759| 0|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 0, False: 0] | | ------------------ ------------------ | Branch (7568:41): [True: 0, False: 0] ------------------ 7569| 0| dest.index = slot_delta + i; 7570| 0| janetc_copy(c, dest, slots[i]); 7571| 0| } 7572| | 7573| | /* Initialize other slots to nil just like in a normal function call */ 7574| | /* TODO - add pass to remove these if needed so we can add this back. 7575| | * The current compiler doesn't rely on nil-initialization behavior but might in the future 7576| | * (e.g. removing redundant ldn at the beginning of a function. 7577| | for (int32_t i = janet_v_count(slots); i < nslots; i++) { 7578| | janetc_emit(c, JOP_LOAD_NIL | ((uint32_t)(i + slot_delta) << 8)); 7579| | } 7580| | */ 7581| | 7582| | /* Do main inlining (patch the bytecode) */ 7583| 0| int32_t const_delta = janet_v_count(scope->consts); /* Get const delta _after_ moving slots. janetc_copy can add constants here! */ ------------------ | | 759| 0|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 0, False: 0] | | ------------------ ------------------ 7584| 0| uint32_t *insert_code = janet_bytecode_inline_chunk(f->def, is_tail ? -1 : target.index, slot_delta, const_delta); ------------------ | Branch (7584:81): [True: 0, False: 0] ------------------ 7585| 0| for (int32_t i = 0; i < janet_v_count(insert_code); i++) { ------------------ | | 759| 0|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 0, False: 0] | | ------------------ ------------------ | Branch (7585:41): [True: 0, False: 0] ------------------ 7586| | /* TODO - better match up source code mapping - e.g. if inlined function 7587| | * is from the same source file */ 7588| 0| janetc_emit(c, insert_code[i]); 7589| 0| } 7590| | /* Copy constants into our constants buffer */ 7591| 0| for (int32_t i = 0; i < f->def->constants_length; i++) { ------------------ | Branch (7591:41): [True: 0, False: 0] ------------------ 7592| 0| janet_v_push(scope->consts, f->def->constants[i]); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 7593| 0| } 7594| 0| janet_v_free(insert_code); ------------------ | | 756| 0|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 0, False: 0] | | ------------------ ------------------ 7595| 0| specialized = 1; 7596| 0| if (is_tail) { ------------------ | Branch (7596:25): [True: 0, False: 0] ------------------ 7597| 0| retslot = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7598| 0| retslot.flags = JANET_SLOT_RETURNED; ------------------ | | 1042| 0|#define JANET_SLOT_RETURNED 0x100000 ------------------ 7599| 0| } else { 7600| 0| retslot = target; 7601| 0| } 7602| 0| } else { 7603| | /*janet_eprintf("inlining failed %V\n", janet_wrap_function(f));*/ 7604| 0| ; 7605| 0| } 7606| 0| janetc_regalloc_free_n(&c->scope->ra, slot_delta, nslots); 7607| 0| } 7608| 190k| } 7609| 309k| } 7610| 341k| if (!specialized) { ------------------ | Branch (7610:9): [True: 150k, False: 190k] ------------------ 7611| 150k| int32_t min_arity = janetc_pushslots(c, slots); 7612| | /* Check for provably incorrect function calls */ 7613| 150k| if (fun.flags & JANET_SLOT_CONSTANT) { ------------------ | | 1038| 150k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (7613:13): [True: 118k, False: 32.1k] ------------------ 7614| | 7615| | /* Check for bad arity type if fun is a constant */ 7616| 118k| switch (janet_type(fun.constant)) { ------------------ | | 795| 118k| (isnan((x).number) \ | | 796| 118k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 118k| : JANET_NUMBER) ------------------ | Branch (7616:21): [True: 118k, False: 193] ------------------ 7617| 52| case JANET_FUNCTION: { ------------------ | Branch (7617:17): [True: 52, False: 118k] ------------------ 7618| 52| JanetFunction *f = janet_unwrap_function(fun.constant); ------------------ | | 868| 52|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 7619| 52| int32_t min = f->def->min_arity; 7620| 52| int32_t max = f->def->max_arity; 7621| 52| int structarg = f->def->flags & JANET_FUNCDEF_FLAG_STRUCTARG; ------------------ | | 1105| 52|#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 ------------------ 7622| 52| int namedarg = f->def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS; ------------------ | | 1107| 52|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ 7623| 52| if (min_arity < 0) { ------------------ | Branch (7623:25): [True: 12, False: 40] ------------------ 7624| | /* Call has splices */ 7625| 12| min_arity = -1 - min_arity; 7626| 12| if (min_arity > max && max >= 0) { ------------------ | Branch (7626:29): [True: 0, False: 12] | Branch (7626:48): [True: 0, False: 0] ------------------ 7627| 0| const uint8_t *es = janet_formatc( 7628| 0| "%v expects at most %d argument%s, got at least %d", 7629| 0| fun.constant, max, max == 1 ? "" : "s", min_arity); ------------------ | Branch (7629:72): [True: 0, False: 0] ------------------ 7630| 0| janetc_error(c, es); 7631| 0| } 7632| 40| } else { 7633| | /* Call has no splices */ 7634| 40| if (min_arity > max && max >= 0) { ------------------ | Branch (7634:29): [True: 37, False: 3] | Branch (7634:48): [True: 37, False: 0] ------------------ 7635| 37| const uint8_t *es = janet_formatc( 7636| 37| "%v expects at most %d argument%s, got %d", 7637| 37| fun.constant, max, max == 1 ? "" : "s", min_arity); ------------------ | Branch (7637:72): [True: 35, False: 2] ------------------ 7638| 37| janetc_error(c, es); 7639| 37| } 7640| 40| if (min_arity < min) { ------------------ | Branch (7640:29): [True: 3, False: 37] ------------------ 7641| 3| const uint8_t *es = janet_formatc( 7642| 3| "%v expects at least %d argument%s, got %d", 7643| 3| fun.constant, min, min == 1 ? "" : "s", min_arity); ------------------ | Branch (7643:72): [True: 0, False: 3] ------------------ 7644| 3| janetc_error(c, es); 7645| 3| } 7646| 40| if (structarg && (min_arity > f->def->arity) && ((min_arity - f->def->arity) & 1)) { ------------------ | Branch (7646:29): [True: 0, False: 40] | Branch (7646:42): [True: 0, False: 0] | Branch (7646:73): [True: 0, False: 0] ------------------ 7647| | /* If we have an odd number of variadic arguments to a `&keys` function, that is almost certainly wrong. */ 7648| 0| if (namedarg) { ------------------ | Branch (7648:33): [True: 0, False: 0] ------------------ 7649| 0| janetc_lintf(c, JANET_C_LINT_NORMAL, 7650| 0| "odd number of named arguments to `&named` function %v", fun.constant); 7651| 0| } else { 7652| 0| janetc_lintf(c, JANET_C_LINT_NORMAL, 7653| 0| "odd number of named arguments to `&keys` function %v", fun.constant); 7654| 0| } 7655| 0| } 7656| 40| if (namedarg && f->def->named_args_count > 0) { ------------------ | Branch (7656:29): [True: 0, False: 40] | Branch (7656:41): [True: 0, False: 0] ------------------ 7657| | /* For each argument passed in, check if it is one of the used named arguments 7658| | * by checking the list defined in the function def. If not, raise a normal compiler 7659| | * lint. We can also do a strict lint for _missing_ named arguments, although in many 7660| | * cases those are assumed to have some kind of default, or we have dynamic keys. */ 7661| 0| int32_t first_arg_key_index = f->def->arity + 1; 7662| 0| for (int32_t i = first_arg_key_index; i < janet_tuple_length(form); i += 2) { ------------------ | | 1802| 0|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 0|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (7662:67): [True: 0, False: 0] ------------------ 7663| 0| Janet argkey = form[i]; 7664| | /* Assumption: The first N constants of a function are its named argument keys. This 7665| | * may change if the compiler changes, but is true for all Janet generated functions. */ 7666| 0| int found = 0; 7667| 0| if (janet_checktype(argkey, JANET_KEYWORD)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7668| 0| for (int32_t j = 0; j < f->def->named_args_count && j < f->def->constants_length; j++) { ------------------ | Branch (7668:57): [True: 0, False: 0] | Branch (7668:89): [True: 0, False: 0] ------------------ 7669| 0| if (janet_equals(argkey, f->def->constants[j])) { ------------------ | Branch (7669:45): [True: 0, False: 0] ------------------ 7670| 0| found = 1; 7671| 0| break; 7672| 0| } 7673| 0| } 7674| 0| } else if (janet_checktype(argkey, JANET_TUPLE)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7675| | /* Possible lint : too dynamic, be dumber 7676| | * (defn f [&named x] [x]) 7677| | * (f (if (coin-flip) :x :w) 10) 7678| | * A tuple could be a function call the evaluates to a valid key */ 7679| 0| found = 1; 7680| 0| } 7681| 0| if (!found) { ------------------ | Branch (7681:37): [True: 0, False: 0] ------------------ 7682| 0| janetc_lintf(c, JANET_C_LINT_NORMAL, 7683| 0| "unused named argument %v to function %v", argkey, fun.constant); 7684| 0| } 7685| 0| } 7686| 0| } 7687| 40| } 7688| 52| } 7689| 52| break; 7690| 112k| case JANET_CFUNCTION: ------------------ | Branch (7690:17): [True: 112k, False: 6.61k] ------------------ 7691| 112k| case JANET_ABSTRACT: ------------------ | Branch (7691:17): [True: 0, False: 118k] ------------------ 7692| 118k| case JANET_NIL: ------------------ | Branch (7692:17): [True: 5.96k, False: 112k] ------------------ 7693| 118k| break; 7694| 40| case JANET_KEYWORD: ------------------ | Branch (7694:17): [True: 40, False: 118k] ------------------ 7695| 40| if (min_arity == 0) { ------------------ | Branch (7695:25): [True: 0, False: 40] ------------------ 7696| 0| const uint8_t *es = janet_formatc("%v expects at least 1 argument, got 0", 7697| 0| fun.constant); 7698| 0| janetc_error(c, es); 7699| 0| } 7700| 40| break; 7701| 559| default: ------------------ | Branch (7701:17): [True: 559, False: 118k] ------------------ 7702| 559| if (min_arity > 1 || min_arity == 0) { ------------------ | Branch (7702:25): [True: 151, False: 408] | Branch (7702:42): [True: 15, False: 393] ------------------ 7703| 166| const uint8_t *es = janet_formatc("%v expects 1 argument, got %d", 7704| 166| fun.constant, min_arity); 7705| 166| janetc_error(c, es); 7706| 166| } 7707| 559| if (min_arity < -2) { ------------------ | Branch (7707:25): [True: 136, False: 423] ------------------ 7708| 136| const uint8_t *es = janet_formatc("%v expects 1 argument, got at least %d", 7709| 136| fun.constant, -1 - min_arity); 7710| 136| janetc_error(c, es); 7711| 136| } 7712| 559| break; 7713| 118k| } 7714| 118k| } 7715| | 7716| 150k| if ((opts.flags & JANET_FOPTS_TAIL) && ------------------ | | 1147| 150k|#define JANET_FOPTS_TAIL 0x10000 ------------------ | Branch (7716:13): [True: 6.42k, False: 144k] ------------------ 7717| | /* Prevent top level tail calls for better errors */ 7718| 6.42k| !(c->scope->flags & JANET_SCOPE_TOP)) { ------------------ | | 1060| 6.42k|#define JANET_SCOPE_TOP 4 ------------------ | Branch (7718:17): [True: 205, False: 6.21k] ------------------ 7719| 205| janetc_emit_s(c, JOP_TAILCALL, fun, 0); 7720| 205| retslot = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 205|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 205| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 205|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 205|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7721| 205| retslot.flags = JANET_SLOT_RETURNED; ------------------ | | 1042| 205|#define JANET_SLOT_RETURNED 0x100000 ------------------ 7722| 150k| } else { 7723| 150k| retslot = janetc_gettarget(opts); 7724| 150k| janetc_emit_ss(c, JOP_CALL, retslot, fun, 1); 7725| 150k| } 7726| 150k| } 7727| 341k| janetc_freeslots(c, slots); 7728| 341k| return retslot; 7729| 341k|} janet.c:has_spliced: 7472| 309k|static int has_spliced(JanetSlot *slots) { 7473| 309k| int32_t i; 7474| 1.46M| for (i = 0; i < janet_v_count(slots); i++) { ------------------ | | 759| 1.46M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.46M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.46M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.46M, False: 318] | | ------------------ ------------------ | Branch (7474:17): [True: 1.15M, False: 309k] ------------------ 7475| 1.15M| if (slots[i].flags & JANET_SLOT_SPLICED) ------------------ | | 1046| 1.15M|#define JANET_SLOT_SPLICED 0x1000000 ------------------ | Branch (7475:13): [True: 148, False: 1.15M] ------------------ 7476| 148| return 1; 7477| 1.15M| } 7478| 309k| return 0; 7479| 309k|} janet.c:function_can_inline: 7509| 40|static int function_can_inline(JanetFopts opts, JanetFunction *func, JanetSlot *slots) { 7510| 40| JanetFuncDef *def = func->def; 7511| | /* TODO - hoist this check to a flag on the func def */ 7512| 40| if (opts.compiler->optimize < 2) return 0; ------------------ | Branch (7512:9): [True: 40, False: 0] ------------------ 7513| 0| if (def->environments_length) return 0; ------------------ | Branch (7513:9): [True: 0, False: 0] ------------------ 7514| 0| if (def->defs_length) return 0; ------------------ | Branch (7514:9): [True: 0, False: 0] ------------------ 7515| 0| if (def->slotcount > 32) return 0; ------------------ | Branch (7515:9): [True: 0, False: 0] ------------------ 7516| 0| if (def->bytecode_length > 40) return 0; ------------------ | Branch (7516:9): [True: 0, False: 0] ------------------ 7517| 0| if (def->flags & (JANET_FUNCDEF_FLAG_NAMEDARGS | JANET_FUNCDEF_FLAG_STRUCTARG | JANET_FUNCDEF_FLAG_VARARG)) return 0; ------------------ | | 1107| 0|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ if (def->flags & (JANET_FUNCDEF_FLAG_NAMEDARGS | JANET_FUNCDEF_FLAG_STRUCTARG | JANET_FUNCDEF_FLAG_VARARG)) return 0; ------------------ | | 1105| 0|#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 ------------------ if (def->flags & (JANET_FUNCDEF_FLAG_NAMEDARGS | JANET_FUNCDEF_FLAG_STRUCTARG | JANET_FUNCDEF_FLAG_VARARG)) return 0; ------------------ | | 1097| 0|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ | Branch (7517:9): [True: 0, False: 0] ------------------ 7518| 0| if (janet_v_count(slots) != def->min_arity) return 0; /* TODO - optional arguments */ ------------------ | | 759| 0|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 0, False: 0] | | ------------------ ------------------ | Branch (7518:9): [True: 0, False: 0] ------------------ 7519| 0| if (janet_v_count(slots) != def->max_arity) return 0; ------------------ | | 759| 0|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 0, False: 0] | | ------------------ ------------------ | Branch (7519:9): [True: 0, False: 0] ------------------ 7520| | /* Check for JOP_LOAD_SELF */ 7521| 0| for (int32_t i = 0; i < def->bytecode_length; i++) { ------------------ | Branch (7521:25): [True: 0, False: 0] ------------------ 7522| 0| if ((def->bytecode[i] & 0x7F) == JOP_LOAD_SELF) return 0; ------------------ | Branch (7522:13): [True: 0, False: 0] ------------------ 7523| 0| } 7524| 0| return 1; 7525| 0|} janet.c:janetc_array: 7771| 1|static JanetSlot janetc_array(JanetFopts opts, Janet x) { 7772| 1| JanetCompiler *c = opts.compiler; 7773| 1| JanetArray *a = janet_unwrap_array(x); ------------------ | | 860| 1|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 7774| 1| return janetc_maker(opts, 7775| 1| janetc_toslots(c, a->data, a->count), 7776| 1| JOP_MAKE_ARRAY); 7777| 1|} janet.c:janetc_tablector: 7787| 36|static JanetSlot janetc_tablector(JanetFopts opts, Janet x, int op) { 7788| 36| JanetCompiler *c = opts.compiler; 7789| 36| return janetc_maker(opts, 7790| 36| janetc_toslotskv(c, x), 7791| 36| op); 7792| 36|} janet.c:janetc_bufferctor: 7794| 35|static JanetSlot janetc_bufferctor(JanetFopts opts, Janet x) { 7795| 35| JanetCompiler *c = opts.compiler; 7796| 35| JanetBuffer *b = janet_unwrap_buffer(x); ------------------ | | 862| 35|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ 7797| 35| Janet onearg = janet_stringv(b->data, b->count); ------------------ | | 1827| 35|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 35|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 35| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 35|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 35|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7798| 35| return janetc_maker(opts, 7799| 35| janetc_toslots(c, &onearg, 1), 7800| 35| JOP_MAKE_BUFFER); 7801| 35|} janet.c:janetc_init: 8137| 57.2k|static void janetc_init(JanetCompiler *c, JanetTable *env, const uint8_t *where, JanetArray *lints) { 8138| 57.2k| c->scope = NULL; 8139| 57.2k| c->buffer = NULL; 8140| 57.2k| c->mapbuffer = NULL; 8141| 57.2k| c->recursion_guard = JANET_RECURSION_GUARD; ------------------ | | 296| 57.2k|#define JANET_RECURSION_GUARD 1024 ------------------ 8142| 57.2k| c->env = env; 8143| 57.2k| c->source = where; 8144| 57.2k| c->current_mapping.line = -1; 8145| 57.2k| c->current_mapping.column = -1; 8146| 57.2k| c->lints = lints; 8147| 57.2k| c->is_redef = janet_truthy(janet_table_get_keyword(c->env, "redef")); ------------------ | | 818| 57.2k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 114k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 57.2k] | | | | ------------------ | | | | 807| 114k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 114k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 57.2k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 57.2k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 57.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 57.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 57.2k] | | ------------------ | | 819| 57.2k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ 8148| 57.2k| c->optimize = to_optimization_level(janet_table_get_keyword(c->env, "optimize")); 8149| | /* Init result */ 8150| 57.2k| c->result.error = NULL; 8151| 57.2k| c->result.status = JANET_COMPILE_OK; 8152| 57.2k| c->result.funcdef = NULL; 8153| | c->result.macrofiber = NULL; 8154| 57.2k| c->result.error_mapping.line = -1; 8155| 57.2k| c->result.error_mapping.column = -1; 8156| 57.2k|} janet.c:to_optimization_level: 8130| 57.2k|static int32_t to_optimization_level(Janet x) { 8131| 57.2k| if (!janet_checkint(x)) return 0; ------------------ | Branch (8131:9): [True: 57.2k, False: 0] ------------------ 8132| 0| int32_t int_level = janet_unwrap_integer(x); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 8133| 0| return int_level; 8134| 57.2k|} janet.c:janetc_deinit: 8159| 57.2k|static void janetc_deinit(JanetCompiler *c) { 8160| 57.2k| janet_v_free(c->buffer); ------------------ | | 756| 57.2k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 25.3k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 25.3k, False: 31.8k] | | ------------------ ------------------ 8161| 57.2k| janet_v_free(c->mapbuffer); ------------------ | | 756| 57.2k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 25.3k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 25.3k, False: 31.8k] | | ------------------ ------------------ 8162| | c->env = NULL; 8163| 57.2k|} janet.c:janet_load_libs: 9373| 264|static void janet_load_libs(JanetTable *env) { 9374| 264| JanetRegExt corelib_cfuns[] = { 9375| 264| JANET_CORE_REG("native", janet_core_native), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9376| 264| JANET_CORE_REG("describe", janet_core_describe), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9377| 264| JANET_CORE_REG("string", janet_core_string), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9378| 264| JANET_CORE_REG("symbol", janet_core_symbol), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9379| 264| JANET_CORE_REG("keyword", janet_core_keyword), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9380| 264| JANET_CORE_REG("buffer", janet_core_buffer), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9381| 264| JANET_CORE_REG("abstract?", janet_core_is_abstract), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9382| 264| JANET_CORE_REG("table", janet_core_table), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9383| 264| JANET_CORE_REG("array", janet_core_array), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9384| 264| JANET_CORE_REG("scan-number", janet_core_scannumber), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9385| 264| JANET_CORE_REG("tuple", janet_core_tuple), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9386| 264| JANET_CORE_REG("struct", janet_core_struct), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9387| 264| JANET_CORE_REG("gensym", janet_core_gensym), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9388| 264| JANET_CORE_REG("gccollect", janet_core_gccollect), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9389| 264| JANET_CORE_REG("gcsetinterval", janet_core_gcsetinterval), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9390| 264| JANET_CORE_REG("gcinterval", janet_core_gcinterval), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9391| 264| JANET_CORE_REG("type", janet_core_type), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9392| 264| JANET_CORE_REG("hash", janet_core_hash), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9393| 264| JANET_CORE_REG("getline", janet_core_getline), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9394| 264| JANET_CORE_REG("dyn", janet_core_dyn), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9395| 264| JANET_CORE_REG("setdyn", janet_core_setdyn), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9396| 264| JANET_CORE_REG("trace", janet_core_trace), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9397| 264| JANET_CORE_REG("untrace", janet_core_untrace), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9398| 264| JANET_CORE_REG("module/expand-path", janet_core_expand_path), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9399| 264| JANET_CORE_REG("int?", janet_core_check_int), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9400| 264| JANET_CORE_REG("nat?", janet_core_check_nat), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9401| 264| JANET_CORE_REG("bytes?", janet_core_is_bytes), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9402| 264| JANET_CORE_REG("indexed?", janet_core_is_indexed), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9403| 264| JANET_CORE_REG("dictionary?", janet_core_is_dictionary), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9404| 264| JANET_CORE_REG("lengthable?", janet_core_is_lengthable), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9405| 264| JANET_CORE_REG("slice", janet_core_slice), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9406| 264| JANET_CORE_REG("range", janet_core_range), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9407| 264| JANET_CORE_REG("signal", janet_core_signal), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9408| 264| JANET_CORE_REG("memcmp", janet_core_memcmp), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9409| 264| JANET_CORE_REG("getproto", janet_core_getproto), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9410| 264| JANET_CORE_REG("sandbox", janet_core_sandbox), ------------------ | | 518| 264|#define JANET_CORE_REG JANET_REG_S | | ------------------ | | | | 2120| 264|#define JANET_REG_S(JNAME, CNAME) {JNAME, CNAME, NULL, __FILE__, CNAME##_sourceline_} | | ------------------ ------------------ 9411| 264| JANET_REG_END ------------------ | | 2110| 264|#define JANET_REG_END {NULL, NULL, NULL, NULL, 0} ------------------ 9412| 264| }; 9413| | janet_core_cfuns_ext(env, NULL, corelib_cfuns); 9414| 264| janet_lib_io(env); 9415| 264| janet_lib_math(env); 9416| 264| janet_lib_array(env); 9417| 264| janet_lib_tuple(env); 9418| 264| janet_lib_buffer(env); 9419| 264| janet_lib_table(env); 9420| 264| janet_lib_struct(env); 9421| 264| janet_lib_fiber(env); 9422| 264| janet_lib_os(env); 9423| 264| janet_lib_parse(env); 9424| 264| janet_lib_compile(env); 9425| 264| janet_lib_debug(env); 9426| 264| janet_lib_string(env); 9427| 264| janet_lib_marsh(env); 9428| 264|#ifdef JANET_PEG 9429| 264| janet_lib_peg(env); 9430| 264|#endif 9431| 264|#ifdef JANET_ASSEMBLER 9432| 264| janet_lib_asm(env); 9433| 264|#endif 9434| 264|#ifdef JANET_INT_TYPES 9435| 264| janet_lib_inttypes(env); 9436| 264|#endif 9437| 264|#ifdef JANET_EV 9438| 264| janet_lib_ev(env); 9439| 264|#ifdef JANET_FILEWATCH 9440| 264| janet_lib_filewatch(env); 9441| 264|#endif 9442| 264|#endif 9443| 264|#ifdef JANET_NET 9444| 264| janet_lib_net(env); 9445| 264|#endif 9446| 264|#ifdef JANET_FFI 9447| 264| janet_lib_ffi(env); 9448| 264|#endif 9449| 264|} janet.c:janetc_movenear: 10315| 8.50M| JanetSlot src) { 10316| 8.50M| janet_assert(dest <= 255, "dest slot index must be <= 255"); ------------------ | | 389| 8.50M|#define janet_assert(c, m) do { \ | | 390| 8.50M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 8.50M] | | ------------------ | | 391| 8.50M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 8.50M] | | ------------------ ------------------ 10317| 8.50M| if (src.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) { ------------------ | | 1038| 8.50M|#define JANET_SLOT_CONSTANT 0x10000 ------------------ if (src.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) { ------------------ | | 1041| 8.50M|#define JANET_SLOT_REF 0x80000 ------------------ | Branch (10317:9): [True: 3.49M, False: 5.01M] ------------------ 10318| 3.49M| janetc_loadconst(c, src.constant, dest); 10319| | /* If we also are a reference, deref the one element array */ 10320| 3.49M| if (src.flags & JANET_SLOT_REF) { ------------------ | | 1041| 3.49M|#define JANET_SLOT_REF 0x80000 ------------------ | Branch (10320:13): [True: 33.5k, False: 3.46M] ------------------ 10321| 33.5k| janetc_emit(c, 10322| 33.5k| ((uint32_t) dest << 16) | 10323| 33.5k| ((uint32_t) dest << 8) | 10324| 33.5k| JOP_GET_INDEX); 10325| 33.5k| } 10326| 5.01M| } else if (src.envindex >= 0) { ------------------ | Branch (10326:16): [True: 7.26k, False: 5.00M] ------------------ 10327| 7.26k| janetc_emit(c, 10328| 7.26k| ((uint32_t)(src.index) << 24) | 10329| 7.26k| ((uint32_t)(src.envindex) << 16) | 10330| 7.26k| ((uint32_t)(dest) << 8) | 10331| 7.26k| JOP_LOAD_UPVALUE); 10332| 5.00M| } else if (src.index != dest) { ------------------ | Branch (10332:16): [True: 5.00M, False: 0] ------------------ 10333| 5.00M| janet_assert(src.index >= 0, "bad slot"); ------------------ | | 389| 5.00M|#define janet_assert(c, m) do { \ | | 390| 5.00M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 5.00M] | | ------------------ | | 391| 5.00M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 5.00M] | | ------------------ ------------------ 10334| 5.00M| janetc_emit(c, 10335| 5.00M| ((uint32_t)(src.index) << 16) | 10336| 5.00M| ((uint32_t)(dest) << 8) | 10337| 5.00M| JOP_MOVE_NEAR); 10338| 5.00M| } 10339| 8.50M|} janet.c:janetc_loadconst: 10277| 3.49M|static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) { 10278| 3.49M| switch (janet_type(k)) { ------------------ | | 795| 3.49M| (isnan((x).number) \ | | 796| 3.49M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 3.49M| : JANET_NUMBER) ------------------ | Branch (10278:13): [True: 2.94M, False: 548k] ------------------ 10279| 696k| case JANET_NIL: ------------------ | Branch (10279:9): [True: 696k, False: 2.80M] ------------------ 10280| 696k| janetc_emit(c, ((uint32_t) reg << 8) | JOP_LOAD_NIL); 10281| 696k| break; 10282| 600| case JANET_BOOLEAN: ------------------ | Branch (10282:9): [True: 600, False: 3.49M] ------------------ 10283| 600| janetc_emit(c, ((uint32_t) reg << 8) | 10284| 600| (janet_unwrap_boolean(k) ? JOP_LOAD_TRUE : JOP_LOAD_FALSE)); ------------------ | | 838| 600|#define janet_unwrap_boolean(x) ((x).u64 & 0x1) | | ------------------ | | | Branch (838:33): [True: 588, False: 12] | | ------------------ ------------------ 10285| 600| break; 10286| 548k| case JANET_NUMBER: { ------------------ | Branch (10286:9): [True: 548k, False: 2.94M] ------------------ 10287| 548k| double dval = janet_unwrap_number(k); ------------------ | | 839| 548k|#define janet_unwrap_number(x) ((x).number) ------------------ 10288| 548k| if (dval < INT16_MIN || dval > INT16_MAX) ------------------ | Branch (10288:17): [True: 334, False: 548k] | Branch (10288:37): [True: 2.60k, False: 545k] ------------------ 10289| 2.93k| goto do_constant; 10290| 545k| int32_t i = (int32_t) dval; 10291| 545k| if (dval != i) ------------------ | Branch (10291:17): [True: 276, False: 545k] ------------------ 10292| 276| goto do_constant; 10293| 545k| uint32_t iu = (uint32_t)i; 10294| 545k| janetc_emit(c, 10295| 545k| ((uint32_t) iu << 16) | 10296| 545k| ((uint32_t) reg << 8) | 10297| 545k| JOP_LOAD_INTEGER); 10298| 545k| break; 10299| 545k| } 10300| 2.25M| default: ------------------ | Branch (10300:9): [True: 2.25M, False: 1.24M] ------------------ 10301| 2.25M| do_constant: { 10302| 2.25M| int32_t cindex = janetc_const(c, k); 10303| 2.25M| janetc_emit(c, 10304| 2.25M| ((uint32_t) cindex << 16) | 10305| 2.25M| ((uint32_t) reg << 8) | 10306| 2.25M| JOP_LOAD_CONSTANT); 10307| 2.25M| break; 10308| 2.25M| } 10309| 3.49M| } 10310| 3.49M|} janet.c:janetc_const: 10252| 2.25M|static int32_t janetc_const(JanetCompiler *c, Janet x) { 10253| 2.25M| JanetScope *scope = c->scope; 10254| 2.25M| int32_t i, len; 10255| | /* Get the topmost function scope */ 10256| 2.73M| while (scope) { ------------------ | Branch (10256:12): [True: 2.73M, False: 0] ------------------ 10257| 2.73M| if (scope->flags & JANET_SCOPE_FUNCTION) ------------------ | | 1058| 2.73M|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (10257:13): [True: 2.25M, False: 480k] ------------------ 10258| 2.25M| break; 10259| 480k| scope = scope->parent; 10260| 480k| } 10261| | /* Check if already added */ 10262| 2.25M| len = janet_v_count(scope->consts); ------------------ | | 759| 2.25M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.19M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.19M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.19M, False: 57.5k] | | ------------------ ------------------ 10263| 7.01M| for (i = 0; i < len; i++) { ------------------ | Branch (10263:17): [True: 6.95M, False: 63.7k] ------------------ 10264| 6.95M| if (janet_equals(x, scope->consts[i])) ------------------ | Branch (10264:13): [True: 2.19M, False: 4.75M] ------------------ 10265| 2.19M| return i; 10266| 6.95M| } 10267| | /* Ensure not too many constants. */ 10268| 63.7k| if (len >= 0xFFFF) { ------------------ | Branch (10268:9): [True: 0, False: 63.7k] ------------------ 10269| 0| janetc_cerror(c, "too many constants"); 10270| 0| return 0; 10271| 0| } 10272| 63.7k| janet_v_push(scope->consts, x); ------------------ | | 757| 63.7k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 63.7k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 63.7k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 6.22k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 6.22k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 6.22k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 6.22k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 57.5k, False: 6.22k] | | | | | | | Branch (768:50): [True: 2.64k, False: 3.58k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 60.1k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 63.7k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 63.7k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 10273| 63.7k| return len; 10274| 63.7k|} janet.c:janetc_moveback: 10344| 5.20M| int32_t src) { 10345| 5.20M| if (dest.flags & JANET_SLOT_REF) { ------------------ | | 1041| 5.20M|#define JANET_SLOT_REF 0x80000 ------------------ | Branch (10345:9): [True: 549, False: 5.20M] ------------------ 10346| 549| int32_t refreg = janetc_regalloc_temp(&c->scope->ra, JANETC_REGTEMP_5); 10347| 549| janetc_loadconst(c, dest.constant, refreg); 10348| 549| janetc_emit(c, 10349| 549| ((uint32_t) src << 16) | 10350| 549| ((uint32_t) refreg << 8) | 10351| 549| JOP_PUT_INDEX); 10352| 549| janetc_regalloc_freetemp(&c->scope->ra, refreg, JANETC_REGTEMP_5); 10353| 5.20M| } else if (dest.envindex >= 0) { ------------------ | Branch (10353:16): [True: 626, False: 5.20M] ------------------ 10354| | /* Convert src to near reg */ 10355| 626| if (src > 255) { ------------------ | Branch (10355:13): [True: 0, False: 626] ------------------ 10356| 0| int32_t newsrc = JANETC_REGTEMP_5 + 0xF0; 10357| 0| janetc_emit(c, JOP_MOVE_NEAR | ((uint32_t)(src) << 16) | ((uint32_t) newsrc << 8)); 10358| 0| src = newsrc; 10359| 0| } 10360| 626| janetc_emit(c, 10361| 626| ((uint32_t)(dest.index) << 24) | 10362| 626| ((uint32_t)(dest.envindex) << 16) | 10363| 626| ((uint32_t)(src) << 8) | 10364| 626| JOP_SET_UPVALUE); 10365| 5.20M| } else if (dest.index != src) { ------------------ | Branch (10365:16): [True: 3.20M, False: 1.99M] ------------------ 10366| 3.20M| janet_assert(dest.index >= 0, "bad slot"); ------------------ | | 389| 3.20M|#define janet_assert(c, m) do { \ | | 390| 3.20M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 3.20M] | | ------------------ | | 391| 3.20M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 3.20M] | | ------------------ ------------------ 10367| | /* Convert src to near reg */ 10368| 3.20M| if (src > 255) { ------------------ | Branch (10368:13): [True: 0, False: 3.20M] ------------------ 10369| 0| int32_t newsrc = JANETC_REGTEMP_5 + 0xF0; 10370| 0| janetc_emit(c, JOP_MOVE_NEAR | ((uint32_t)(src) << 16) | ((uint32_t)newsrc << 8)); 10371| 0| src = newsrc; 10372| 0| } 10373| 3.20M| janetc_emit(c, 10374| 3.20M| ((uint32_t)(dest.index) << 16) | 10375| 3.20M| ((uint32_t)(src) << 8) | 10376| 3.20M| JOP_MOVE_FAR); 10377| 3.20M| } 10378| 5.20M|} janet.c:janetc_regfar: 10391| 4.02M|static int32_t janetc_regfar(JanetCompiler *c, JanetSlot s, JanetcRegisterTemp tag) { 10392| | /* check if already near register */ 10393| 4.02M| if (s.envindex < 0 && s.index >= 0) { ------------------ | Branch (10393:9): [True: 4.02M, False: 3.70k] | Branch (10393:27): [True: 3.06M, False: 954k] ------------------ 10394| 3.06M| return s.index; 10395| 3.06M| } 10396| 958k| int32_t reg; 10397| 958k| int32_t nearreg = janetc_regalloc_temp(&c->scope->ra, tag); 10398| 958k| janetc_movenear(c, nearreg, s); 10399| 958k| if (nearreg >= 0xF0) { ------------------ | Branch (10399:9): [True: 844k, False: 114k] ------------------ 10400| 844k| reg = janetc_allocfar(c); 10401| 844k| janetc_emit(c, JOP_MOVE_FAR | ((uint32_t) nearreg << 8) | ((uint32_t) reg << 16)); 10402| 844k| janetc_regalloc_freetemp(&c->scope->ra, nearreg, tag); 10403| 844k| } else { 10404| 114k| reg = nearreg; 10405| 114k| janetc_regalloc_freetemp(&c->scope->ra, nearreg, tag); 10406| 114k| janetc_regalloc_touch(&c->scope->ra, reg); 10407| 114k| } 10408| 958k| return reg; 10409| 4.02M|} janet.c:janetc_free_regnear: 10381| 11.1M|static void janetc_free_regnear(JanetCompiler *c, JanetSlot s, int32_t reg, JanetcRegisterTemp tag) { 10382| 11.1M| if (reg != s.index || ------------------ | Branch (10382:9): [True: 7.24M, False: 3.91M] ------------------ 10383| 3.91M| s.envindex >= 0 || ------------------ | Branch (10383:13): [True: 663, False: 3.91M] ------------------ 10384| 7.24M| s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) { ------------------ | | 1038| 3.91M|#define JANET_SLOT_CONSTANT 0x10000 ------------------ s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) { ------------------ | | 1041| 3.91M|#define JANET_SLOT_REF 0x80000 ------------------ | Branch (10384:13): [True: 0, False: 3.91M] ------------------ 10385| | /* We need to free the temporary slot */ 10386| 7.24M| janetc_regalloc_freetemp(&c->scope->ra, reg, tag); 10387| 7.24M| } 10388| 11.1M|} janet.c:emit1s: 10467| 204k|static int32_t emit1s(JanetCompiler *c, uint8_t op, JanetSlot s, int32_t rest, int wr) { 10468| 204k| int32_t reg = janetc_regnear(c, s, JANETC_REGTEMP_0); 10469| 204k| int32_t label = janet_v_count(c->buffer); ------------------ | | 759| 204k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 204k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 204k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 204k, False: 0] | | ------------------ ------------------ 10470| 204k| janetc_emit(c, op | ((uint32_t) reg << 8) | ((uint32_t) rest << 16)); 10471| 204k| if (wr) ------------------ | Branch (10471:9): [True: 200k, False: 4.82k] ------------------ 10472| 200k| janetc_moveback(c, s, reg); 10473| 204k| janetc_free_regnear(c, s, reg, JANETC_REGTEMP_0); 10474| 204k| return label; 10475| 204k|} janet.c:janetc_regnear: 10412| 7.13M|static int32_t janetc_regnear(JanetCompiler *c, JanetSlot s, JanetcRegisterTemp tag) { 10413| | /* check if already near register */ 10414| 7.13M| if (s.envindex < 0 && s.index >= 0 && s.index <= 0xFF) { ------------------ | Branch (10414:9): [True: 7.12M, False: 3.11k] | Branch (10414:27): [True: 4.69M, False: 2.43M] | Branch (10414:43): [True: 848k, False: 3.84M] ------------------ 10415| 848k| return s.index; 10416| 848k| } 10417| 6.28M| int32_t reg = janetc_regalloc_temp(&c->scope->ra, tag); 10418| 6.28M| janetc_movenear(c, reg, s); 10419| 6.28M| return reg; 10420| 7.13M|} janet.c:emit2s: 10508| 1.87M|static int32_t emit2s(JanetCompiler *c, uint8_t op, JanetSlot s1, JanetSlot s2, int32_t rest, int wr) { 10509| 1.87M| int32_t reg1 = janetc_regnear(c, s1, JANETC_REGTEMP_0); 10510| 1.87M| int32_t reg2 = janetc_regnear(c, s2, JANETC_REGTEMP_1); 10511| 1.87M| int32_t label = janet_v_count(c->buffer); ------------------ | | 759| 1.87M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.87M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.87M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.87M, False: 63] | | ------------------ ------------------ 10512| 1.87M| janetc_emit(c, op | ((uint32_t) reg1 << 8) | ((uint32_t) reg2 << 16) | ((uint32_t)rest << 24)); 10513| 1.87M| janetc_free_regnear(c, s2, reg2, JANETC_REGTEMP_1); 10514| 1.87M| if (wr) ------------------ | Branch (10514:9): [True: 1.87M, False: 2.18k] ------------------ 10515| 1.87M| janetc_moveback(c, s1, reg1); 10516| 1.87M| janetc_free_regnear(c, s1, reg1, JANETC_REGTEMP_0); 10517| 1.87M| return label; 10518| 1.87M|} janet.c:janet_q_init: 10684| 264|static void janet_q_init(JanetQueue *q) { 10685| | q->data = NULL; 10686| 264| q->head = 0; 10687| 264| q->tail = 0; 10688| 264| q->capacity = 0; 10689| 264|} janet.c:peek_timeout: 10766| 264|static int peek_timeout(JanetTimeout *out) { 10767| 264| if (janet_vm.tq_count == 0) return 0; ------------------ | Branch (10767:9): [True: 264, False: 0] ------------------ 10768| 0| *out = janet_vm.tq[0]; 10769| 0| return 1; 10770| 264|} janet.c:janet_q_deinit: 10691| 264|static void janet_q_deinit(JanetQueue *q) { 10692| 264| janet_free(q->data); ------------------ | | 2415| 264|#define janet_free(X) free((X)) ------------------ 10693| 264|} janet.c:janet_ev_setup_selfpipe: 12253| 264|static void janet_ev_setup_selfpipe(void) { 12254| 264| if (janet_make_pipe(janet_vm.selfpipe, 1)) { ------------------ | Branch (12254:9): [True: 0, False: 264] ------------------ 12255| | JANET_EXIT("failed to initialize self pipe in event loop"); ------------------ | | 378| 0|#define JANET_EXIT(m) do { \ | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | 380| 0| __FILE__,\ | | 381| 0| __LINE__,\ | | 382| 0| (m));\ | | 383| 0| abort();\ | | 384| 0|} while (0) | | ------------------ | | | Branch (384:10): [Folded, False: 0] | | ------------------ ------------------ 12256| 0| } 12257| 264|} janet.c:janet_ev_cleanup_selfpipe: 12276| 264|static void janet_ev_cleanup_selfpipe(void) { 12277| 264| close(janet_vm.selfpipe[0]); 12278| 264| close(janet_vm.selfpipe[1]); 12279| 264|} janet.c:fiber_reset: 16302| 68.6k|static void fiber_reset(JanetFiber *fiber) { 16303| 68.6k| fiber->maxstack = JANET_STACK_MAX; ------------------ | | 307| 68.6k|#define JANET_STACK_MAX 0x7fffffff ------------------ 16304| 68.6k| fiber->frame = 0; 16305| 68.6k| fiber->stackstart = JANET_FRAME_SIZE; ------------------ | | 1026| 68.6k|#define JANET_FRAME_SIZE 4 ------------------ 16306| 68.6k| fiber->stacktop = JANET_FRAME_SIZE; ------------------ | | 1026| 68.6k|#define JANET_FRAME_SIZE 4 ------------------ 16307| 68.6k| fiber->child = NULL; 16308| 68.6k| fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; ------------------ | | 814| 68.6k|#define JANET_FIBER_MASK_YIELD 8 ------------------ fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; ------------------ | | 835| 68.6k|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ fiber->flags = JANET_FIBER_MASK_YIELD | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; ------------------ | | 836| 68.6k|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 ------------------ 16309| 68.6k| fiber->env = NULL; 16310| 68.6k| fiber->last_value = janet_wrap_nil(); ------------------ | | 831| 68.6k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 68.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 16311| 68.6k|#ifdef JANET_EV 16312| 68.6k| fiber->sched_id = 0; 16313| 68.6k| fiber->ev_callback = NULL; 16314| 68.6k| fiber->ev_state = NULL; 16315| 68.6k| fiber->ev_stream = NULL; 16316| 68.6k| fiber->supervisor_channel = NULL; 16317| 68.6k|#endif 16318| 68.6k| janet_fiber_set_status(fiber, JANET_STATUS_NEW); ------------------ | | 849| 68.6k|#define janet_fiber_set_status(f, s) do {\ | | 850| 68.6k| (f)->flags &= ~JANET_FIBER_STATUS_MASK;\ | | ------------------ | | | | 830| 68.6k|#define JANET_FIBER_STATUS_MASK 0x3F0000 | | ------------------ | | 851| 68.6k| (f)->flags |= (s) << JANET_FIBER_STATUS_OFFSET;\ | | ------------------ | | | | 832| 68.6k|#define JANET_FIBER_STATUS_OFFSET 16 | | ------------------ | | 852| 68.6k|} while (0) | | ------------------ | | | Branch (852:10): [Folded, False: 68.6k] | | ------------------ ------------------ 16319| 68.6k|} janet.c:fiber_alloc: 16321| 68.6k|static JanetFiber *fiber_alloc(int32_t capacity) { 16322| 68.6k| Janet *data; 16323| 68.6k| JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber)); 16324| 68.6k| if (capacity < 32) { ------------------ | Branch (16324:9): [True: 0, False: 68.6k] ------------------ 16325| 0| capacity = 32; 16326| 0| } 16327| 68.6k| fiber->capacity = capacity; 16328| 68.6k| data = array_allocate(sizeof(Janet), capacity); 16329| 68.6k| if (NULL == data) { ------------------ | Branch (16329:9): [True: 0, False: 68.6k] ------------------ 16330| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16331| 0| } 16332| 68.6k| janet_vm.next_collection += sizeof(Janet) * capacity; 16333| 68.6k| fiber->data = data; 16334| 68.6k| return fiber; 16335| 68.6k|} janet.c:janet_fiber_grow: 16400| 5.68k|static void janet_fiber_grow(JanetFiber *fiber, int32_t needed) { 16401| 5.68k| int32_t cap = needed > (INT32_MAX / 2) ? INT32_MAX : 2 * needed; ------------------ | Branch (16401:19): [True: 0, False: 5.68k] ------------------ 16402| 5.68k| janet_fiber_setcapacity(fiber, cap); 16403| 5.68k|} janet.c:janet_env_detach: 16525| 14.4M|static void janet_env_detach(JanetFuncEnv *env) { 16526| | /* Check for closure environment */ 16527| 14.4M| if (env) { ------------------ | Branch (16527:9): [True: 1.49M, False: 12.9M] ------------------ 16528| 1.49M| janet_env_valid(env); 16529| 1.49M| int32_t len = env->length; /* Maximum is 256 */ 16530| 1.49M| size_t s = sizeof(Janet) * (size_t) len; 16531| 1.49M| Janet *vmem = janet_malloc(s); ------------------ | | 2406| 1.49M|#define janet_malloc(X) malloc((X)) ------------------ 16532| 1.49M| janet_vm.next_collection += (uint32_t) s; 16533| 1.49M| if (NULL == vmem) { ------------------ | Branch (16533:13): [True: 0, False: 1.49M] ------------------ 16534| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 16535| 0| } 16536| 1.49M| Janet *values = env->as.fiber->data + env->offset; 16537| 1.49M| safe_memcpy(vmem, values, s); 16538| 1.49M| uint32_t *bitset = janet_stack_frame(values)->func->def->closure_bitset; ------------------ | | 854| 1.49M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 1.49M|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 16539| 1.49M| if (bitset) { ------------------ | Branch (16539:13): [True: 1.49M, False: 0] ------------------ 16540| | /* Clear unneeded references in closure environment */ 16541| 2.99M| for (int32_t i = 0; i < len; i += 32) { ------------------ | Branch (16541:33): [True: 1.49M, False: 1.49M] ------------------ 16542| 1.49M| uint32_t mask = ~(bitset[i >> 5]); 16543| 1.49M| int32_t maxj = i + 32 > len ? len : i + 32; ------------------ | Branch (16543:32): [True: 1.49M, False: 0] ------------------ 16544| 46.4M| for (int32_t j = i; j < maxj; j++) { ------------------ | Branch (16544:37): [True: 44.9M, False: 1.49M] ------------------ 16545| 44.9M| if (mask & 1) vmem[j] = janet_wrap_nil(); ------------------ | | 831| 36.2M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 36.2M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 36.2M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 36.2M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (16545:25): [True: 36.2M, False: 8.66M] ------------------ 16546| 44.9M| mask >>= 1; 16547| 44.9M| } 16548| 1.49M| } 16549| 1.49M| } 16550| 1.49M| env->offset = 0; 16551| 1.49M| env->as.values = vmem; 16552| 1.49M| } 16553| 14.4M|} janet.c:janet_deinit_block: 18286| 34.9M|static void janet_deinit_block(JanetGCObject *mem) { 18287| 34.9M| switch (mem->flags & JANET_MEM_TYPEBITS) { ------------------ | | 675| 34.9M|#define JANET_MEM_TYPEBITS 0xFF ------------------ 18288| 16.8M| default: ------------------ | Branch (18288:9): [True: 16.8M, False: 18.1M] ------------------ 18289| 29.9M| case JANET_MEMORY_FUNCTION: ------------------ | Branch (18289:9): [True: 13.1M, False: 21.8M] ------------------ 18290| 29.9M| break; /* Do nothing for non gc types */ 18291| 1.13M| case JANET_MEMORY_SYMBOL: ------------------ | Branch (18291:9): [True: 1.13M, False: 33.8M] ------------------ 18292| 1.13M| janet_symbol_deinit(((JanetStringHead *) mem)->data); 18293| 1.13M| break; 18294| 1.33M| case JANET_MEMORY_ARRAY: ------------------ | Branch (18294:9): [True: 1.33M, False: 33.6M] ------------------ 18295| 1.33M| case JANET_MEMORY_ARRAY_WEAK: ------------------ | Branch (18295:9): [True: 0, False: 34.9M] ------------------ 18296| 1.33M| janet_free(((JanetArray *) mem)->data); ------------------ | | 2415| 1.33M|#define janet_free(X) free((X)) ------------------ 18297| 1.33M| break; 18298| 300k| case JANET_MEMORY_TABLE: ------------------ | Branch (18298:9): [True: 300k, False: 34.6M] ------------------ 18299| 300k| case JANET_MEMORY_TABLE_WEAKK: ------------------ | Branch (18299:9): [True: 0, False: 34.9M] ------------------ 18300| 300k| case JANET_MEMORY_TABLE_WEAKV: ------------------ | Branch (18300:9): [True: 0, False: 34.9M] ------------------ 18301| 300k| case JANET_MEMORY_TABLE_WEAKKV: ------------------ | Branch (18301:9): [True: 0, False: 34.9M] ------------------ 18302| 300k| janet_free(((JanetTable *) mem)->data); ------------------ | | 2415| 300k|#define janet_free(X) free((X)) ------------------ 18303| 300k| break; 18304| 68.6k| case JANET_MEMORY_FIBER: { ------------------ | Branch (18304:9): [True: 68.6k, False: 34.9M] ------------------ 18305| 68.6k| JanetFiber *f = (JanetFiber *)mem; 18306| 68.6k|#ifdef JANET_EV 18307| 68.6k| if (f->ev_state && !(f->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) { ------------------ | | 847| 0|#define JANET_FIBER_EV_FLAG_IN_FLIGHT 0x1 ------------------ | Branch (18307:17): [True: 0, False: 68.6k] | Branch (18307:32): [True: 0, False: 0] ------------------ 18308| 0| janet_ev_dec_refcount(); 18309| 0| janet_free(f->ev_state); ------------------ | | 2415| 0|#define janet_free(X) free((X)) ------------------ 18310| 68.6k| } else if (f->gc.flags & JANET_FIBER_EV_GCFLAG_SUSPENDED) { ------------------ | | 843| 68.6k|#define JANET_FIBER_EV_GCFLAG_SUSPENDED 0x2000000 ------------------ | Branch (18310:24): [True: 0, False: 68.6k] ------------------ 18311| 0| janet_ev_dec_refcount(); 18312| 0| } 18313| 68.6k|#endif 18314| 68.6k| janet_free(f->data); ------------------ | | 2415| 68.6k|#define janet_free(X) free((X)) ------------------ 18315| 68.6k| } 18316| 68.6k| break; 18317| 5.72k| case JANET_MEMORY_BUFFER: ------------------ | Branch (18317:9): [True: 5.72k, False: 34.9M] ------------------ 18318| 5.72k| janet_buffer_deinit((JanetBuffer *) mem); 18319| 5.72k| break; 18320| 6.91k| case JANET_MEMORY_ABSTRACT: { ------------------ | Branch (18320:9): [True: 6.91k, False: 34.9M] ------------------ 18321| 6.91k| JanetAbstractHead *head = (JanetAbstractHead *)mem; 18322| 6.91k| if (head->type->gcperthread) { ------------------ | Branch (18322:17): [True: 0, False: 6.91k] ------------------ 18323| 0| janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 18324| 0| } 18325| 6.91k| if (head->type->gc) { ------------------ | Branch (18325:17): [True: 792, False: 6.11k] ------------------ 18326| 792| janet_assert(!head->type->gc(head->data, head->size), "finalizer failed"); ------------------ | | 389| 792|#define janet_assert(c, m) do { \ | | 390| 792| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 792] | | ------------------ | | 391| 792|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 792] | | ------------------ ------------------ 18327| 792| } 18328| 6.91k| } 18329| 6.91k| break; 18330| 1.88M| case JANET_MEMORY_FUNCENV: { ------------------ | Branch (18330:9): [True: 1.88M, False: 33.1M] ------------------ 18331| 1.88M| JanetFuncEnv *env = (JanetFuncEnv *)mem; 18332| 1.88M| if (0 == env->offset) ------------------ | Branch (18332:17): [True: 1.49M, False: 389k] ------------------ 18333| 1.49M| janet_free(env->as.values); ------------------ | | 2415| 1.49M|#define janet_free(X) free((X)) ------------------ 18334| 1.88M| } 18335| 1.88M| break; 18336| 291k| case JANET_MEMORY_FUNCDEF: { ------------------ | Branch (18336:9): [True: 291k, False: 34.7M] ------------------ 18337| 291k| JanetFuncDef *def = (JanetFuncDef *)mem; 18338| | /* TODO - get this all with one alloc and one free */ 18339| 291k| janet_free(def->defs); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18340| 291k| janet_free(def->environments); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18341| 291k| janet_free(def->constants); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18342| 291k| janet_free(def->bytecode); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18343| 291k| janet_free(def->sourcemap); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18344| 291k| janet_free(def->closure_bitset); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18345| 291k| janet_free(def->symbolmap); ------------------ | | 2415| 291k|#define janet_free(X) free((X)) ------------------ 18346| 291k| } 18347| 291k| break; 18348| 34.9M| } 18349| 34.9M|} janet.c:janet_free_all_scratch: 18536| 264|static void janet_free_all_scratch(void) { 18537| 6.27k| for (size_t i = 0; i < janet_vm.scratch_len; i++) { ------------------ | Branch (18537:24): [True: 6.01k, False: 264] ------------------ 18538| 6.01k| free_one_scratch(janet_vm.scratch_mem[i]); 18539| 6.01k| } 18540| 264| janet_vm.scratch_len = 0; 18541| 264|} janet.c:janet_mem2scratch: 18543| 4.58M|static JanetScratch *janet_mem2scratch(void *mem) { 18544| 4.58M| JanetScratch *s = (JanetScratch *)mem; 18545| 4.58M| return s - 1; 18546| 4.58M|} janet.c:free_one_scratch: 18528| 2.54M|static void free_one_scratch(JanetScratch *s) { 18529| 2.54M| if (NULL != s->finalize) { ------------------ | Branch (18529:9): [True: 0, False: 2.54M] ------------------ 18530| 0| s->finalize((char *) s->mem); 18531| 0| } 18532| 2.54M| janet_free(s); ------------------ | | 2415| 2.54M|#define janet_free(X) free((X)) ------------------ 18533| 2.54M|} janet.c:it_s64_tostring: 18829| 3|static void it_s64_tostring(void *p, JanetBuffer *buffer) { 18830| 3| char str[32]; 18831| | snprintf(str, sizeof(str), "%" PRId64, *((int64_t *)p)); 18832| 3| janet_buffer_push_cstring(buffer, str); 18833| 3|} janet.c:janet_int64_hash: 18800| 4.21k|static int32_t janet_int64_hash(void *p1, size_t size) { 18801| 4.21k| (void) size; 18802| 4.21k| int32_t *words = p1; 18803| 4.21k| return words[0] ^ words[1]; 18804| 4.21k|} janet.c:it_u64_tostring: 18835| 141|static void it_u64_tostring(void *p, JanetBuffer *buffer) { 18836| 141| char str[32]; 18837| | snprintf(str, sizeof(str), "%" PRIu64, *((uint64_t *)p)); 18838| 141| janet_buffer_push_cstring(buffer, str); 18839| 141|} janet.c:janet_int64_next: 19402| 3|static Janet janet_int64_next(void *p, Janet key) { 19403| 3| (void) p; 19404| 3| return janet_nextmethod(it_s64_methods, key); 19405| 3|} janet.c:it_s64_get: 19412| 3|static int it_s64_get(void *p, Janet key, Janet *out) { 19413| 3| (void) p; 19414| 3| if (!janet_checktype(key, JANET_KEYWORD)) ------------------ | | 806| 3| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 3] | | ------------------ | | 807| 3| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (19414:9): [True: 3, False: 0] ------------------ 19415| 3| return 0; 19416| 0| return janet_getmethod(janet_unwrap_keyword(key), it_s64_methods, out); ------------------ | | 865| 0|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 19417| 3|} janet.c:it_u64_get: 19419| 132|static int it_u64_get(void *p, Janet key, Janet *out) { 19420| 132| (void) p; 19421| 132| if (!janet_checktype(key, JANET_KEYWORD)) ------------------ | | 806| 132| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 132] | | ------------------ | | 807| 132| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 132| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 132| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 132|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 132|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 132|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (19421:9): [True: 0, False: 132] ------------------ 19422| 0| return 0; 19423| 132| return janet_getmethod(janet_unwrap_keyword(key), it_u64_methods, out); ------------------ | | 865| 132|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ 19424| 132|} janet.c:makef: 19558| 792|static void *makef(FILE *f, int32_t flags, size_t bufsize) { 19559| 792| JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile)); 19560| 792| iof->file = f; 19561| 792| iof->flags = flags; 19562| 792| iof->vbufsize = bufsize; 19563| 792|#if !(defined(JANET_WINDOWS) || defined(JANET_PLAN9)) 19564| | /* While we would like fopen to set cloexec by default (like O_CLOEXEC) with the e flag, that is 19565| | * not standard. */ 19566| 792| if (!(flags & JANET_FILE_NOT_CLOSEABLE)) ------------------ | | 2278| 792|#define JANET_FILE_NOT_CLOSEABLE 16 ------------------ | Branch (19566:9): [True: 0, False: 792] ------------------ 19567| 0| fcntl(fileno(f), F_SETFD, FD_CLOEXEC); 19568| 792|#endif 19569| 792| return iof; 19570| 792|} janet.c:cfun_io_gc: 19766| 792|static int cfun_io_gc(void *p, size_t len) { 19767| 792| (void) len; 19768| 792| JanetFile *iof = (JanetFile *)p; 19769| 792| janet_file_close(iof); 19770| 792| return 0; 19771| 792|} janet.c:readint: 21050| 17.9M|static int32_t readint(UnmarshalState *st, const uint8_t **atdata) { 21051| 17.9M| const uint8_t *data = *atdata; 21052| 17.9M| int32_t ret; 21053| 17.9M| MARSH_EOS(st, data); ------------------ | |21045| 17.9M|#define MARSH_EOS(st, data) do { \ | |21046| 17.9M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 17.9M] | | ------------------ | |21047| 17.9M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 17.9M] | | ------------------ ------------------ 21054| 17.9M| if (*data < 128) { ------------------ | Branch (21054:9): [True: 14.5M, False: 3.32M] ------------------ 21055| 14.5M| ret = *data++; 21056| 14.5M| } else if (*data < 192) { ------------------ | Branch (21056:16): [True: 3.13M, False: 186k] ------------------ 21057| 3.13M| MARSH_EOS(st, data + 1); ------------------ | |21045| 3.13M|#define MARSH_EOS(st, data) do { \ | |21046| 3.13M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 3.13M] | | ------------------ | |21047| 3.13M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 3.13M] | | ------------------ ------------------ 21058| 3.13M| uint32_t uret = ((data[0] & 0x3F) << 8) + data[1]; 21059| | /* Sign extend 18 MSBs */ 21060| 3.13M| uret |= (uret >> 13) ? 0xFFFFC000 : 0; ------------------ | Branch (21060:17): [True: 877k, False: 2.25M] ------------------ 21061| 3.13M| ret = (int32_t)uret; 21062| 3.13M| data += 2; 21063| 3.13M| } else if (*data == LB_INTEGER) { ------------------ | Branch (21063:16): [True: 186k, False: 0] ------------------ 21064| 186k| MARSH_EOS(st, data + 4); ------------------ | |21045| 186k|#define MARSH_EOS(st, data) do { \ | |21046| 186k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 186k] | | ------------------ | |21047| 186k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 186k] | | ------------------ ------------------ 21065| 186k| uint32_t ui = ((uint32_t)(data[1]) << 24) | 21066| 186k| ((uint32_t)(data[2]) << 16) | 21067| 186k| ((uint32_t)(data[3]) << 8) | 21068| 186k| (uint32_t)(data[4]); 21069| 186k| ret = (int32_t)ui; 21070| 186k| data += 5; 21071| 186k| } else { 21072| 0| janet_panicf("expected integer, got byte %x at index %d", 21073| 0| *data, 21074| 0| data - st->start); 21075| 0| ret = 0; 21076| 0| } 21077| 17.9M| *atdata = data; 21078| 17.9M| return ret; 21079| 17.9M|} janet.c:unmarshal_one: 21659| 4.79M| int flags) { 21660| 4.79M| uint8_t lead; 21661| 4.79M| MARSH_STACKCHECK; ------------------ | |20517| 4.79M|#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow") | | ------------------ | | | | 296| 4.79M|#define JANET_RECURSION_GUARD 1024 | | ------------------ | | | Branch (20517:30): [True: 0, False: 4.79M] | | ------------------ ------------------ 21662| 4.79M| MARSH_EOS(st, data); ------------------ | |21045| 4.79M|#define MARSH_EOS(st, data) do { \ | |21046| 4.79M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 4.79M] | | ------------------ | |21047| 4.79M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 4.79M] | | ------------------ ------------------ 21663| 4.79M| lead = data[0]; 21664| 4.79M| if (lead < LB_REAL) { ------------------ | Branch (21664:9): [True: 364k, False: 4.43M] ------------------ 21665| 364k| *out = janet_wrap_integer(readint(st, &data)); ------------------ | | 967| 364k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 364k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 21666| 364k| return data; 21667| 364k| } 21668| 4.43M| switch (lead) { 21669| 14.5k| case LB_NIL: ------------------ | Branch (21669:9): [True: 14.5k, False: 4.41M] ------------------ 21670| 14.5k| *out = janet_wrap_nil(); ------------------ | | 831| 14.5k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 14.5k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 14.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 14.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21671| 14.5k| return data + 1; 21672| 0| case LB_FALSE: ------------------ | Branch (21672:9): [True: 0, False: 4.43M] ------------------ 21673| 0| *out = janet_wrap_false(); ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21674| 0| return data + 1; 21675| 35.1k| case LB_TRUE: ------------------ | Branch (21675:9): [True: 35.1k, False: 4.39M] ------------------ 21676| 35.1k| *out = janet_wrap_true(); ------------------ | | 832| 35.1k|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 35.1k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 35.1k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 35.1k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21677| 35.1k| return data + 1; 21678| 792| case LB_INTEGER: ------------------ | Branch (21678:9): [True: 792, False: 4.42M] ------------------ 21679| | /* Long integer */ 21680| 792| MARSH_EOS(st, data + 4); ------------------ | |21045| 792|#define MARSH_EOS(st, data) do { \ | |21046| 792| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 792] | | ------------------ | |21047| 792|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 792] | | ------------------ ------------------ 21681| 792| uint32_t ui = ((uint32_t)(data[4])) | 21682| 792| ((uint32_t)(data[3]) << 8) | 21683| 792| ((uint32_t)(data[2]) << 16) | 21684| 792| ((uint32_t)(data[1]) << 24); 21685| 792| int32_t si = (int32_t)ui; 21686| 792| *out = janet_wrap_integer(si); ------------------ | | 967| 792|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 792|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 21687| 792| return data + 5; 21688| 1.84k| case LB_REAL: ------------------ | Branch (21688:9): [True: 1.84k, False: 4.42M] ------------------ 21689| | /* Real */ 21690| 1.84k| { 21691| 1.84k| union { 21692| 1.84k| double d; 21693| 1.84k| uint8_t bytes[8]; 21694| 1.84k| } u; 21695| 1.84k| MARSH_EOS(st, data + 8); ------------------ | |21045| 1.84k|#define MARSH_EOS(st, data) do { \ | |21046| 1.84k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 1.84k] | | ------------------ | |21047| 1.84k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 1.84k] | | ------------------ ------------------ 21696| |#ifdef JANET_BIG_ENDIAN 21697| | u.bytes[0] = data[8]; 21698| | u.bytes[1] = data[7]; 21699| | u.bytes[2] = data[6]; 21700| | u.bytes[3] = data[5]; 21701| | u.bytes[4] = data[4]; 21702| | u.bytes[5] = data[3]; 21703| | u.bytes[6] = data[2]; 21704| | u.bytes[7] = data[1]; 21705| |#else 21706| 1.84k| memcpy(&u.bytes, data + 1, sizeof(double)); 21707| 1.84k|#endif 21708| 1.84k| *out = janet_wrap_number_safe(u.d); 21709| 1.84k| janet_v_push(st->lookup, *out); ------------------ | | 757| 1.84k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.84k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.84k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.84k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.84k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 1.84k] | | | | | | | Branch (768:50): [True: 0, False: 1.84k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.84k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21710| 1.84k| return data + 9; 21711| 1.84k| } 21712| 390k| case LB_STRING: ------------------ | Branch (21712:9): [True: 390k, False: 4.03M] ------------------ 21713| 883k| case LB_SYMBOL: ------------------ | Branch (21713:9): [True: 492k, False: 3.93M] ------------------ 21714| 883k| case LB_BUFFER: ------------------ | Branch (21714:9): [True: 264, False: 4.43M] ------------------ 21715| 946k| case LB_KEYWORD: ------------------ | Branch (21715:9): [True: 62.8k, False: 4.36M] ------------------ 21716| 1.04M| case LB_REGISTRY: { ------------------ | Branch (21716:9): [True: 93.7k, False: 4.33M] ------------------ 21717| 1.04M| data++; 21718| 1.04M| int32_t len = readnat(st, &data); 21719| 1.04M| MARSH_EOS(st, data - 1 + len); ------------------ | |21045| 1.04M|#define MARSH_EOS(st, data) do { \ | |21046| 1.04M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 1.04M] | | ------------------ | |21047| 1.04M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 1.04M] | | ------------------ ------------------ 21720| 1.04M| if (lead == LB_STRING) { ------------------ | Branch (21720:17): [True: 390k, False: 649k] ------------------ 21721| 390k| const uint8_t *str = janet_string(data, len); 21722| 390k| *out = janet_wrap_string(str); ------------------ | | 848| 390k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 390k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 390k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 390k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21723| 649k| } else if (lead == LB_SYMBOL) { ------------------ | Branch (21723:24): [True: 492k, False: 156k] ------------------ 21724| 492k| const uint8_t *str = janet_symbol(data, len); 21725| 492k| *out = janet_wrap_symbol(str); ------------------ | | 849| 492k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 492k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 492k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 492k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21726| 492k| } else if (lead == LB_KEYWORD) { ------------------ | Branch (21726:24): [True: 62.8k, False: 93.9k] ------------------ 21727| 62.8k| const uint8_t *str = janet_keyword(data, len); ------------------ | | 1840| 62.8k|#define janet_keyword janet_symbol ------------------ 21728| 62.8k| *out = janet_wrap_keyword(str); ------------------ | | 850| 62.8k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | ------------------ | | | | 828| 62.8k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 62.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 62.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21729| 93.9k| } else if (lead == LB_REGISTRY) { ------------------ | Branch (21729:24): [True: 93.7k, False: 264] ------------------ 21730| 93.7k| if (st->reg) { ------------------ | Branch (21730:21): [True: 93.7k, False: 0] ------------------ 21731| 93.7k| Janet regkey = janet_symbolv(data, len); ------------------ | | 1836| 93.7k|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 93.7k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 93.7k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 93.7k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 93.7k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21732| 93.7k| *out = janet_table_get(st->reg, regkey); 21733| 93.7k| } else { 21734| 0| *out = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21735| 0| } 21736| 93.7k| } else { /* (lead == LB_BUFFER) */ 21737| 264| JanetBuffer *buffer = janet_buffer(len); 21738| 264| buffer->count = len; 21739| 264| safe_memcpy(buffer->data, data, len); 21740| 264| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 264|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 264| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 264|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21741| 264| } 21742| 1.04M| janet_v_push(st->lookup, *out); ------------------ | | 757| 1.04M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.04M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.04M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.04M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.04M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.04M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.04M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 1.04M] | | | | | | | Branch (768:50): [True: 3.16k, False: 1.03M] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 3.16k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.04M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.04M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21743| 1.04M| return data + len; 21744| 1.04M| } 21745| 0| case LB_FIBER: { ------------------ | Branch (21745:9): [True: 0, False: 4.43M] ------------------ 21746| 0| JanetFiber *fiber; 21747| 0| data = unmarshal_one_fiber(st, data + 1, &fiber, flags + 1); 21748| 0| *out = janet_wrap_fiber(fiber); ------------------ | | 844| 0|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21749| 0| return data; 21750| 1.04M| } 21751| 101k| case LB_FUNCTION: { ------------------ | Branch (21751:9): [True: 101k, False: 4.32M] ------------------ 21752| 101k| JanetFunction *func; 21753| 101k| JanetFuncDef *def; 21754| 101k| data++; 21755| 101k| int32_t len = readnat(st, &data); 21756| 101k| if (len > 255) { ------------------ | Branch (21756:17): [True: 0, False: 101k] ------------------ 21757| 0| janet_panicf("invalid function - too many environments (%d)", len); 21758| 0| } 21759| 101k| func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + 21760| 101k| len * sizeof(JanetFuncEnv)); 21761| 101k| func->def = NULL; 21762| 112k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21762:33): [True: 11.3k, False: 101k] ------------------ 21763| 11.3k| func->envs[i] = NULL; 21764| 11.3k| } 21765| 101k| *out = janet_wrap_function(func); ------------------ | | 852| 101k|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 825| 101k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 101k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 101k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21766| 101k| janet_v_push(st->lookup, *out); ------------------ | | 757| 101k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 101k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 101k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 101k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 101k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 101k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 101k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 101k] | | | | | | | Branch (768:50): [True: 0, False: 101k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 101k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 101k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21767| 101k| data = unmarshal_one_def(st, data, &def, flags + 1); 21768| 101k| func->def = def; 21769| 112k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21769:33): [True: 11.3k, False: 101k] ------------------ 21770| 11.3k| data = unmarshal_one_env(st, data, &(func->envs[i]), flags + 1); 21771| 11.3k| } 21772| 101k| return data; 21773| 101k| } 21774| 0| case LB_ABSTRACT: { ------------------ | Branch (21774:9): [True: 0, False: 4.43M] ------------------ 21775| 0| data++; 21776| 0| return unmarshal_one_abstract(st, data, out, flags); 21777| 101k| } 21778| 2.84M| case LB_REFERENCE: ------------------ | Branch (21778:9): [True: 2.84M, False: 1.58M] ------------------ 21779| 2.84M| case LB_ARRAY: ------------------ | Branch (21779:9): [True: 792, False: 4.42M] ------------------ 21780| 2.84M| case LB_ARRAY_WEAK: ------------------ | Branch (21780:9): [True: 0, False: 4.43M] ------------------ 21781| 3.04M| case LB_TUPLE: ------------------ | Branch (21781:9): [True: 198k, False: 4.23M] ------------------ 21782| 3.04M| case LB_STRUCT: ------------------ | Branch (21782:9): [True: 1.84k, False: 4.42M] ------------------ 21783| 3.04M| case LB_STRUCT_PROTO: ------------------ | Branch (21783:9): [True: 0, False: 4.43M] ------------------ 21784| 3.23M| case LB_TABLE: ------------------ | Branch (21784:9): [True: 192k, False: 4.23M] ------------------ 21785| 3.23M| case LB_TABLE_PROTO: ------------------ | Branch (21785:9): [True: 0, False: 4.43M] ------------------ 21786| 3.23M| case LB_TABLE_WEAKK: ------------------ | Branch (21786:9): [True: 0, False: 4.43M] ------------------ 21787| 3.23M| case LB_TABLE_WEAKV: ------------------ | Branch (21787:9): [True: 0, False: 4.43M] ------------------ 21788| 3.23M| case LB_TABLE_WEAKKV: ------------------ | Branch (21788:9): [True: 0, False: 4.43M] ------------------ 21789| 3.23M| case LB_TABLE_WEAKK_PROTO: ------------------ | Branch (21789:9): [True: 0, False: 4.43M] ------------------ 21790| 3.23M| case LB_TABLE_WEAKV_PROTO: ------------------ | Branch (21790:9): [True: 0, False: 4.43M] ------------------ 21791| 3.23M| case LB_TABLE_WEAKKV_PROTO: ------------------ | Branch (21791:9): [True: 0, False: 4.43M] ------------------ 21792| | /* Things that open with integers */ 21793| 3.23M| { 21794| 3.23M| data++; 21795| 3.23M| int32_t len = readnat(st, &data); 21796| | /* DOS check */ 21797| 3.23M| if (lead != LB_REFERENCE) { ------------------ | Branch (21797:17): [True: 394k, False: 2.84M] ------------------ 21798| 394k| MARSH_EOS(st, data - 1 + len); ------------------ | |21045| 394k|#define MARSH_EOS(st, data) do { \ | |21046| 394k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 394k] | | ------------------ | |21047| 394k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 394k] | | ------------------ ------------------ 21799| 394k| } 21800| 3.23M| if (lead == LB_ARRAY || lead == LB_ARRAY_WEAK) { ------------------ | Branch (21800:17): [True: 792, False: 3.23M] | Branch (21800:37): [True: 0, False: 3.23M] ------------------ 21801| | /* Array */ 21802| 792| JanetArray *array = (lead == LB_ARRAY_WEAK) ? janet_array_weak(len) : janet_array(len); ------------------ | Branch (21802:37): [True: 0, False: 792] ------------------ 21803| 792| array->count = len; 21804| 792| *out = janet_wrap_array(array); ------------------ | | 845| 792|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 792| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 792|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 792|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21805| 792| janet_v_push(st->lookup, *out); ------------------ | | 757| 792|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 792|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 792|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 792|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 792|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 792|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 792|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 792] | | | | | | | Branch (768:50): [True: 0, False: 792] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 792|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 792|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21806| 6.86k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21806:37): [True: 6.07k, False: 792] ------------------ 21807| 6.07k| data = unmarshal_one(st, data, array->data + i, flags + 1); 21808| 6.07k| } 21809| 3.23M| } else if (lead == LB_TUPLE) { ------------------ | Branch (21809:24): [True: 198k, False: 3.03M] ------------------ 21810| | /* Tuple */ 21811| 198k| Janet *tup = janet_tuple_begin(len); 21812| 198k| int32_t flag = readint(st, &data); 21813| 198k| janet_tuple_flag(tup) |= (int32_t)(((uint32_t) flag) << 16); /* Avoid left shift of negative value */ ------------------ | | 1806| 198k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 198k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 21814| 785k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21814:37): [True: 587k, False: 198k] ------------------ 21815| 587k| data = unmarshal_one(st, data, tup + i, flags + 1); 21816| 587k| } 21817| 198k| *out = janet_wrap_tuple(janet_tuple_end(tup)); ------------------ | | 843| 198k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 198k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 198k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 198k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21818| 198k| janet_v_push(st->lookup, *out); ------------------ | | 757| 198k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 198k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 198k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 198k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 198k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 198k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 198k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 198k] | | | | | | | Branch (768:50): [True: 0, False: 198k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 198k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 198k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21819| 3.03M| } else if (lead == LB_STRUCT || lead == LB_STRUCT_PROTO) { ------------------ | Branch (21819:24): [True: 1.84k, False: 3.03M] | Branch (21819:45): [True: 0, False: 3.03M] ------------------ 21820| | /* Struct */ 21821| 1.84k| JanetKV *struct_ = janet_struct_begin(len); 21822| 1.84k| if (lead == LB_STRUCT_PROTO) { ------------------ | Branch (21822:21): [True: 0, False: 1.84k] ------------------ 21823| 0| Janet proto; 21824| 0| data = unmarshal_one(st, data, &proto, flags + 1); 21825| 0| janet_asserttype(proto, JANET_STRUCT, st); 21826| 0| janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 1851| 0|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ janet_struct_proto(struct_) = janet_unwrap_struct(proto); ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 21827| 0| } 21828| 14.2k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21828:37): [True: 12.4k, False: 1.84k] ------------------ 21829| 12.4k| Janet key, value; 21830| 12.4k| data = unmarshal_one(st, data, &key, flags + 1); 21831| 12.4k| data = unmarshal_one(st, data, &value, flags + 1); 21832| 12.4k| janet_struct_put(struct_, key, value); 21833| 12.4k| } 21834| 1.84k| *out = janet_wrap_struct(janet_struct_end(struct_)); ------------------ | | 842| 1.84k|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 1.84k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.84k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.84k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21835| 1.84k| janet_v_push(st->lookup, *out); ------------------ | | 757| 1.84k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 1.84k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 1.84k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.84k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.84k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 1.84k] | | | | | | | Branch (768:50): [True: 0, False: 1.84k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 1.84k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21836| 3.03M| } else if (lead == LB_REFERENCE) { ------------------ | Branch (21836:24): [True: 2.84M, False: 192k] ------------------ 21837| 2.84M| if (len >= janet_v_count(st->lookup)) ------------------ | | 759| 2.84M|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 2.84M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.84M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 2.84M, False: 0] | | ------------------ ------------------ | Branch (21837:21): [True: 0, False: 2.84M] ------------------ 21838| 0| janet_panicf("invalid reference %d", len); 21839| 2.84M| *out = st->lookup[len]; 21840| 2.84M| } else { 21841| | /* Table */ 21842| 192k| JanetTable *t; 21843| 192k| if (lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKK) { ------------------ | Branch (21843:21): [True: 0, False: 192k] | Branch (21843:53): [True: 0, False: 192k] ------------------ 21844| 0| t = janet_table_weakk(len); 21845| 192k| } else if (lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKV) { ------------------ | Branch (21845:28): [True: 0, False: 192k] | Branch (21845:60): [True: 0, False: 192k] ------------------ 21846| 0| t = janet_table_weakv(len); 21847| 192k| } else if (lead == LB_TABLE_WEAKKV_PROTO || lead == LB_TABLE_WEAKKV) { ------------------ | Branch (21847:28): [True: 0, False: 192k] | Branch (21847:61): [True: 0, False: 192k] ------------------ 21848| 0| t = janet_table_weakkv(len); 21849| 192k| } else { 21850| 192k| t = janet_table(len); 21851| 192k| } 21852| 192k| *out = janet_wrap_table(t); ------------------ | | 846| 192k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 192k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 192k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 192k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21853| 192k| janet_v_push(st->lookup, *out); ------------------ | | 757| 192k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 192k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 192k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 192k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 192k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 192k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 192k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 264, False: 192k] | | | | | | | Branch (768:50): [True: 264, False: 192k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 528|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 192k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 192k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21854| 192k| if (lead == LB_TABLE_PROTO || lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKKV_PROTO) { ------------------ | Branch (21854:21): [True: 0, False: 192k] | Branch (21854:47): [True: 0, False: 192k] | Branch (21854:79): [True: 0, False: 192k] | Branch (21854:111): [True: 0, False: 192k] ------------------ 21855| 0| Janet proto; 21856| 0| data = unmarshal_one(st, data, &proto, flags + 1); 21857| 0| janet_asserttype(proto, JANET_TABLE, st); 21858| 0| t->proto = janet_unwrap_table(proto); ------------------ | | 861| 0|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 21859| 0| } 21860| 1.16M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (21860:37): [True: 972k, False: 192k] ------------------ 21861| 972k| Janet key, value; 21862| 972k| data = unmarshal_one(st, data, &key, flags + 1); 21863| 972k| data = unmarshal_one(st, data, &value, flags + 1); 21864| 972k| janet_table_put(t, key, value); 21865| 972k| } 21866| 192k| } 21867| 3.23M| return data; 21868| 3.23M| } 21869| 0| case LB_UNSAFE_POINTER: { ------------------ | Branch (21869:9): [True: 0, False: 4.43M] ------------------ 21870| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21045| 0|#define MARSH_EOS(st, data) do { \ | |21046| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 0] | | ------------------ | |21047| 0|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 0] | | ------------------ ------------------ 21871| 0| data++; 21872| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21872:17): [True: 0, False: 0] ------------------ 21873| 0| janet_panicf("unsafe flag not given, " 21874| 0| "will not unmarshal raw pointer at index %d", 21875| 0| (int)(data - st->start)); 21876| 0| } 21877| 0| union { 21878| 0| void *ptr; 21879| 0| uint8_t bytes[sizeof(void *)]; 21880| 0| } u; 21881| 0| memcpy(u.bytes, data, sizeof(void *)); 21882| 0| data += sizeof(void *); 21883| 0| *out = janet_wrap_pointer(u.ptr); ------------------ | | 854| 0|#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21884| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21885| 0| return data; 21886| 0| } 21887| 0|#ifdef JANET_EV 21888| 0| case LB_POINTER_BUFFER: { ------------------ | Branch (21888:9): [True: 0, False: 4.43M] ------------------ 21889| 0| data++; 21890| 0| int32_t count = readnat(st, &data); 21891| 0| int32_t capacity = readnat(st, &data); 21892| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21045| 0|#define MARSH_EOS(st, data) do { \ | |21046| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 0] | | ------------------ | |21047| 0|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 0] | | ------------------ ------------------ 21893| 0| union { 21894| 0| void *ptr; 21895| 0| uint8_t bytes[sizeof(void *)]; 21896| 0| } u; 21897| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21897:17): [True: 0, False: 0] ------------------ 21898| 0| janet_panicf("unsafe flag not given, " 21899| 0| "will not unmarshal raw pointer at index %d", 21900| 0| (int)(data - st->start)); 21901| 0| } 21902| 0| memcpy(u.bytes, data, sizeof(void *)); 21903| 0| data += sizeof(void *); 21904| 0| JanetBuffer *buffer = janet_pointer_buffer_unsafe(u.ptr, capacity, count); 21905| 0| *out = janet_wrap_buffer(buffer); ------------------ | | 847| 0|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21906| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21907| 0| return data; 21908| 0| } 21909| 0|#endif 21910| 0| case LB_UNSAFE_CFUNCTION: { ------------------ | Branch (21910:9): [True: 0, False: 4.43M] ------------------ 21911| 0| MARSH_EOS(st, data + sizeof(JanetCFunction)); ------------------ | |21045| 0|#define MARSH_EOS(st, data) do { \ | |21046| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 0] | | ------------------ | |21047| 0|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 0] | | ------------------ ------------------ 21912| 0| data++; 21913| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21913:17): [True: 0, False: 0] ------------------ 21914| 0| janet_panicf("unsafe flag not given, " 21915| 0| "will not unmarshal function pointer at index %d", 21916| 0| (int)(data - st->start)); 21917| 0| } 21918| 0| union { 21919| 0| JanetCFunction ptr; 21920| 0| uint8_t bytes[sizeof(JanetCFunction)]; 21921| 0| } u; 21922| 0| memcpy(u.bytes, data, sizeof(JanetCFunction)); 21923| 0| data += sizeof(JanetCFunction); 21924| 0| *out = janet_wrap_cfunction(u.ptr); ------------------ | | 853| 0|#define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21925| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21926| 0| return data; 21927| 0| } 21928| 0|#ifdef JANET_EV 21929| 0| case LB_THREADED_ABSTRACT: { ------------------ | Branch (21929:9): [True: 0, False: 4.43M] ------------------ 21930| 0| MARSH_EOS(st, data + sizeof(void *)); ------------------ | |21045| 0|#define MARSH_EOS(st, data) do { \ | |21046| 0| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 0] | | ------------------ | |21047| 0|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 0] | | ------------------ ------------------ 21931| 0| data++; 21932| 0| if (!(flags & JANET_MARSHAL_UNSAFE)) { ------------------ | | 1911| 0|#define JANET_MARSHAL_UNSAFE 0x20000 ------------------ | Branch (21932:17): [True: 0, False: 0] ------------------ 21933| 0| janet_panicf("unsafe flag not given, " 21934| 0| "will not unmarshal threaded abstract pointer at index %d", 21935| 0| (int)(data - st->start)); 21936| 0| } 21937| 0| union { 21938| 0| void *ptr; 21939| 0| uint8_t bytes[sizeof(void *)]; 21940| 0| } u; 21941| 0| memcpy(u.bytes, data, sizeof(void *)); 21942| 0| data += sizeof(void *); 21943| | 21944| 0| if (flags & JANET_MARSHAL_DECREF) { ------------------ | | 387| 0|#define JANET_MARSHAL_DECREF 0x40000 ------------------ | Branch (21944:17): [True: 0, False: 0] ------------------ 21945| | /* Decrement immediately and don't bother putting into heap */ 21946| 0| janet_abstract_decref(u.ptr); 21947| 0| *out = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21948| 0| } else { 21949| 0| *out = janet_wrap_abstract(u.ptr); ------------------ | | 851| 0|#define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21950| 0| Janet check = janet_table_get(&janet_vm.threaded_abstracts, *out); 21951| 0| if (janet_checktype(check, JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21952| | /* Transfers reference from threaded channel buffer to current heap */ 21953| 0| janet_table_put(&janet_vm.threaded_abstracts, *out, janet_wrap_false()); ------------------ | | 833| 0|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 21954| 0| } else { 21955| | /* Heap reference already accounted for, remove threaded channel reference. */ 21956| 0| janet_abstract_decref(u.ptr); 21957| 0| } 21958| 0| } 21959| | 21960| 0| janet_v_push(st->lookup, *out); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21961| 0| return data; 21962| 0| } 21963| 0|#endif 21964| 0| default: { ------------------ | Branch (21964:9): [True: 0, False: 4.43M] ------------------ 21965| 0| janet_panicf("unknown byte %x at index %d", 21966| 0| *data, 21967| 0| (int)(data - st->start)); 21968| 0| return NULL; 21969| 0| } 21970| 4.43M| } 21971| 4.43M|} janet.c:readnat: 21082| 5.51M|static int32_t readnat(UnmarshalState *st, const uint8_t **atdata) { 21083| 5.51M| int32_t ret = readint(st, atdata); 21084| 5.51M| if (ret < 0) { ------------------ | Branch (21084:9): [True: 0, False: 5.51M] ------------------ 21085| 0| janet_panicf("expected integer >= 0, got %d", ret); 21086| 0| } 21087| 5.51M| return ret; 21088| 5.51M|} janet.c:unmarshal_one_def: 21221| 142k| int flags) { 21222| 142k| MARSH_EOS(st, data); ------------------ | |21045| 142k|#define MARSH_EOS(st, data) do { \ | |21046| 142k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 142k] | | ------------------ | |21047| 142k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 142k] | | ------------------ ------------------ 21223| 142k| if (*data == LB_FUNCDEF_REF) { ------------------ | Branch (21223:9): [True: 1.05k, False: 141k] ------------------ 21224| 1.05k| data++; 21225| 1.05k| int32_t index = readint(st, &data); 21226| 1.05k| if (index < 0 || index >= janet_v_count(st->lookup_defs)) ------------------ | | 759| 1.05k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.05k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.05k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.05k, False: 0] | | ------------------ ------------------ | Branch (21226:13): [True: 0, False: 1.05k] | Branch (21226:26): [True: 0, False: 1.05k] ------------------ 21227| 0| janet_panicf("invalid funcdef reference %d", index); 21228| 1.05k| *out = st->lookup_defs[index]; 21229| 141k| } else { 21230| | /* Initialize with values that will not break garbage collection 21231| | * if unmarshalling fails. */ 21232| 141k| JanetFuncDef *def = janet_gcalloc(JANET_MEMORY_FUNCDEF, sizeof(JanetFuncDef)); 21233| 141k| def->environments_length = 0; 21234| 141k| def->defs_length = 0; 21235| 141k| def->constants_length = 0; 21236| 141k| def->bytecode_length = 0; 21237| 141k| def->name = NULL; 21238| 141k| def->source = NULL; 21239| 141k| def->closure_bitset = NULL; 21240| 141k| def->defs = NULL; 21241| 141k| def->environments = NULL; 21242| 141k| def->constants = NULL; 21243| 141k| def->bytecode = NULL; 21244| 141k| def->sourcemap = NULL; 21245| 141k| def->symbolmap = NULL; 21246| 141k| def->symbolmap_length = 0; 21247| 141k| def->named_args_count = 0; 21248| 141k| janet_v_push(st->lookup_defs, def); ------------------ | | 757| 141k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 141k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 141k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 140k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 140k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 140k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 140k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 264, False: 140k] | | | | | | | Branch (768:50): [True: 2.64k, False: 138k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 2.90k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 141k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 141k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21249| | 21250| | /* Set default lengths to zero */ 21251| 141k| int32_t bytecode_length = 0; 21252| 141k| int32_t constants_length = 0; 21253| 141k| int32_t environments_length = 0; 21254| 141k| int32_t defs_length = 0; 21255| 141k| int32_t symbolmap_length = 0; 21256| | 21257| | /* Read flags and other fixed values */ 21258| 141k| def->flags = readint(st, &data); 21259| 141k| def->slotcount = readnat(st, &data); 21260| 141k| def->arity = readnat(st, &data); 21261| 141k| def->min_arity = readnat(st, &data); 21262| 141k| def->max_arity = readnat(st, &data); 21263| | 21264| | /* Read some lengths */ 21265| 141k| constants_length = readnat(st, &data); 21266| 141k| bytecode_length = readnat(st, &data); 21267| 141k| if (def->flags & JANET_FUNCDEF_FLAG_NAMEDARGS) ------------------ | | 1107| 141k|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (21267:13): [True: 528, False: 140k] ------------------ 21268| 528| def->named_args_count = readnat(st, &data); 21269| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) ------------------ | | 1103| 141k|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (21269:13): [True: 132k, False: 8.71k] ------------------ 21270| 132k| environments_length = readnat(st, &data); 21271| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) ------------------ | | 1102| 141k|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (21271:13): [True: 18.4k, False: 122k] ------------------ 21272| 18.4k| defs_length = readnat(st, &data); 21273| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) ------------------ | | 1099| 141k|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (21273:13): [True: 130k, False: 10.5k] ------------------ 21274| 130k| symbolmap_length = readnat(st, &data); 21275| | 21276| | /* Check name and source (optional) */ 21277| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASNAME) { ------------------ | | 1100| 141k|#define JANET_FUNCDEF_FLAG_HASNAME 0x80000 ------------------ | Branch (21277:13): [True: 132k, False: 8.97k] ------------------ 21278| 132k| Janet x; 21279| 132k| data = unmarshal_one(st, data, &x, flags + 1); 21280| 132k| janet_asserttype(x, JANET_STRING, st); 21281| 132k| def->name = janet_unwrap_string(x); ------------------ | | 863| 132k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 21282| 132k| } 21283| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCE) { ------------------ | | 1101| 141k|#define JANET_FUNCDEF_FLAG_HASSOURCE 0x100000 ------------------ | Branch (21283:13): [True: 132k, False: 8.71k] ------------------ 21284| 132k| Janet x; 21285| 132k| data = unmarshal_one(st, data, &x, flags + 1); 21286| 132k| janet_asserttype(x, JANET_STRING, st); 21287| 132k| def->source = janet_unwrap_string(x); ------------------ | | 863| 132k|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 21288| 132k| } 21289| | 21290| | /* Unmarshal constants */ 21291| 141k| if (constants_length) { ------------------ | Branch (21291:13): [True: 107k, False: 33.5k] ------------------ 21292| 107k| def->constants = array_allocate(sizeof(Janet), constants_length); 21293| 107k| if (!def->constants) { ------------------ | Branch (21293:17): [True: 0, False: 107k] ------------------ 21294| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21295| 0| } 21296| 707k| for (int32_t i = 0; i < constants_length; i++) ------------------ | Branch (21296:33): [True: 599k, False: 107k] ------------------ 21297| 599k| data = unmarshal_one(st, data, def->constants + i, flags + 1); 21298| 107k| } else { 21299| 33.5k| def->constants = NULL; 21300| 33.5k| } 21301| 141k| def->constants_length = constants_length; 21302| | 21303| | /* Unmarshal symbol map, if needed */ 21304| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASSYMBOLMAP) { ------------------ | | 1099| 141k|#define JANET_FUNCDEF_FLAG_HASSYMBOLMAP 0x40000 ------------------ | Branch (21304:13): [True: 130k, False: 10.5k] ------------------ 21305| 130k| def->symbolmap = array_allocate(sizeof(JanetSymbolMap), symbolmap_length); 21306| 130k| if (def->symbolmap == NULL) { ------------------ | Branch (21306:17): [True: 0, False: 130k] ------------------ 21307| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21308| 0| } 21309| 1.47M| for (int32_t i = 0; i < symbolmap_length; i++) { ------------------ | Branch (21309:33): [True: 1.34M, False: 130k] ------------------ 21310| 1.34M| def->symbolmap[i].birth_pc = (uint32_t) readint(st, &data); 21311| 1.34M| def->symbolmap[i].death_pc = (uint32_t) readint(st, &data); 21312| 1.34M| def->symbolmap[i].slot_index = (uint32_t) readint(st, &data); 21313| 1.34M| Janet value; 21314| 1.34M| data = unmarshal_one(st, data, &value, flags + 1); 21315| 1.34M| if (!janet_checktype(value, JANET_SYMBOL)) { ------------------ | | 806| 1.34M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 1.34M] | | ------------------ | | 807| 1.34M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.34M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.34M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.34M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.34M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.34M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (21315:21): [True: 0, False: 1.34M] ------------------ 21316| 0| janet_panicf("corrupted symbolmap when unmarshalling debug info, got %v", value); 21317| 0| } 21318| 1.34M| def->symbolmap[i].symbol = janet_unwrap_symbol(value); ------------------ | | 864| 1.34M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 21319| 1.34M| } 21320| 130k| def->symbolmap_length = (uint32_t) symbolmap_length; 21321| 130k| } 21322| | 21323| | /* Unmarshal bytecode */ 21324| 141k| def->bytecode = array_allocate(sizeof(uint32_t), bytecode_length); 21325| 141k| if (!def->bytecode) { ------------------ | Branch (21325:13): [True: 0, False: 141k] ------------------ 21326| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21327| 0| } 21328| 141k| data = janet_unmarshal_u32s(st, data, def->bytecode, bytecode_length); 21329| 141k| def->bytecode_length = bytecode_length; 21330| | 21331| | /* Unmarshal environments */ 21332| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASENVS) { ------------------ | | 1103| 141k|#define JANET_FUNCDEF_FLAG_HASENVS 0x400000 ------------------ | Branch (21332:13): [True: 132k, False: 8.71k] ------------------ 21333| 132k| def->environments = janet_calloc(1, sizeof(int32_t) * (size_t) environments_length); ------------------ | | 2412| 132k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 21334| 132k| if (!def->environments) { ------------------ | Branch (21334:17): [True: 0, False: 132k] ------------------ 21335| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21336| 0| } 21337| 184k| for (int32_t i = 0; i < environments_length; i++) { ------------------ | Branch (21337:33): [True: 52.0k, False: 132k] ------------------ 21338| 52.0k| def->environments[i] = readint(st, &data); 21339| 52.0k| } 21340| 132k| } else { 21341| 8.71k| def->environments = NULL; 21342| 8.71k| } 21343| 141k| def->environments_length = environments_length; 21344| | 21345| | /* Unmarshal sub funcdefs */ 21346| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASDEFS) { ------------------ | | 1102| 141k|#define JANET_FUNCDEF_FLAG_HASDEFS 0x200000 ------------------ | Branch (21346:13): [True: 18.4k, False: 122k] ------------------ 21347| 18.4k| def->defs = janet_calloc(1, sizeof(JanetFuncDef *) * (size_t) defs_length); ------------------ | | 2412| 18.4k|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 21348| 18.4k| if (!def->defs) { ------------------ | Branch (21348:17): [True: 0, False: 18.4k] ------------------ 21349| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21350| 0| } 21351| 59.6k| for (int32_t i = 0; i < defs_length; i++) { ------------------ | Branch (21351:33): [True: 41.1k, False: 18.4k] ------------------ 21352| 41.1k| data = unmarshal_one_def(st, data, def->defs + i, flags + 1); 21353| 41.1k| } 21354| 122k| } else { 21355| 122k| def->defs = NULL; 21356| 122k| } 21357| 141k| def->defs_length = defs_length; 21358| | 21359| | /* Unmarshal source maps if needed */ 21360| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASSOURCEMAP) { ------------------ | | 1104| 141k|#define JANET_FUNCDEF_FLAG_HASSOURCEMAP 0x800000 ------------------ | Branch (21360:13): [True: 132k, False: 8.71k] ------------------ 21361| 132k| int32_t current = 0; 21362| 132k| def->sourcemap = array_allocate(sizeof(JanetSourceMapping), bytecode_length); 21363| 132k| if (!def->sourcemap) { ------------------ | Branch (21363:17): [True: 0, False: 132k] ------------------ 21364| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21365| 0| } 21366| 3.93M| for (int32_t i = 0; i < bytecode_length; i++) { ------------------ | Branch (21366:33): [True: 3.80M, False: 132k] ------------------ 21367| 3.80M| current += readint(st, &data); 21368| 3.80M| def->sourcemap[i].line = current; 21369| 3.80M| def->sourcemap[i].column = readint(st, &data); 21370| 3.80M| } 21371| 132k| } else { 21372| 8.71k| def->sourcemap = NULL; 21373| 8.71k| } 21374| | 21375| | /* Unmarshal closure bitset if needed */ 21376| 141k| if (def->flags & JANET_FUNCDEF_FLAG_HASCLOBITSET) { ------------------ | | 1106| 141k|#define JANET_FUNCDEF_FLAG_HASCLOBITSET 0x2000000 ------------------ | Branch (21376:13): [True: 15.5k, False: 125k] ------------------ 21377| 15.5k| int32_t n = ((def->slotcount - 1) >> 5) + 1; 21378| 15.5k| def->closure_bitset = array_allocate(sizeof(uint32_t), n); 21379| 15.5k| if (NULL == def->closure_bitset) { ------------------ | Branch (21379:17): [True: 0, False: 15.5k] ------------------ 21380| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21381| 0| } 21382| 15.5k| data = janet_unmarshal_u32s(st, data, def->closure_bitset, n); 21383| 15.5k| } 21384| | 21385| | /* Validate */ 21386| 141k| int status; 21387| 141k| if ((status = janet_verify(def))) { ------------------ | Branch (21387:13): [True: 0, False: 141k] ------------------ 21388| 0| janet_panicf("funcdef has invalid bytecode: %d", status); 21389| 0| } 21390| | 21391| | /* Set def */ 21392| 141k| *out = def; 21393| 141k| } 21394| 142k| return data; 21395| 142k|} janet.c:janet_unmarshal_u32s: 21203| 156k|static const uint8_t *janet_unmarshal_u32s(UnmarshalState *st, const uint8_t *data, uint32_t *into, int32_t n) { 21204| 4.07M| for (int32_t i = 0; i < n; i++) { ------------------ | Branch (21204:25): [True: 3.92M, False: 156k] ------------------ 21205| 3.92M| MARSH_EOS(st, data + 3); ------------------ | |21045| 3.92M|#define MARSH_EOS(st, data) do { \ | |21046| 3.92M| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 3.92M] | | ------------------ | |21047| 3.92M|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 3.92M] | | ------------------ ------------------ 21206| 3.92M| into[i] = 21207| 3.92M| (uint32_t)(data[0]) | 21208| 3.92M| ((uint32_t)(data[1]) << 8) | 21209| 3.92M| ((uint32_t)(data[2]) << 16) | 21210| 3.92M| ((uint32_t)(data[3]) << 24); 21211| 3.92M| data += 4; 21212| 3.92M| } 21213| 156k| return data; 21214| 156k|} janet.c:unmarshal_one_env: 21159| 11.3k| int flags) { 21160| 11.3k| MARSH_EOS(st, data); ------------------ | |21045| 11.3k|#define MARSH_EOS(st, data) do { \ | |21046| 11.3k| if ((data) >= (st)->end) janet_panic("unexpected end of source");\ | | ------------------ | | | Branch (21046:9): [True: 0, False: 11.3k] | | ------------------ | |21047| 11.3k|} while (0) | | ------------------ | | | Branch (21047:10): [Folded, False: 11.3k] | | ------------------ ------------------ 21161| 11.3k| if (*data == LB_FUNCENV_REF) { ------------------ | Branch (21161:9): [True: 9.24k, False: 2.11k] ------------------ 21162| 9.24k| data++; 21163| 9.24k| int32_t index = readint(st, &data); 21164| 9.24k| if (index < 0 || index >= janet_v_count(st->lookup_envs)) ------------------ | | 759| 9.24k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 9.24k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 9.24k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 9.24k, False: 0] | | ------------------ ------------------ | Branch (21164:13): [True: 0, False: 9.24k] | Branch (21164:26): [True: 0, False: 9.24k] ------------------ 21165| 0| janet_panicf("invalid funcenv reference %d", index); 21166| 9.24k| *out = st->lookup_envs[index]; 21167| 9.24k| } else { 21168| 2.11k| JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); 21169| 2.11k| env->length = 0; 21170| 2.11k| env->offset = 0; 21171| 2.11k| env->as.values = NULL; 21172| 2.11k| janet_v_push(st->lookup_envs, env); ------------------ | | 757| 2.11k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 2.11k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 2.11k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.84k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.84k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.84k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 264, False: 1.84k] | | | | | | | Branch (768:50): [True: 1.05k, False: 792] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 1.32k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 2.11k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 2.11k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 21173| 2.11k| int32_t offset = readnat(st, &data); 21174| 2.11k| int32_t length = readnat(st, &data); 21175| 2.11k| if (offset > 0) { ------------------ | Branch (21175:13): [True: 0, False: 2.11k] ------------------ 21176| 0| Janet fiberv; 21177| | /* On stack variant */ 21178| 0| data = unmarshal_one(st, data, &fiberv, flags); 21179| 0| janet_asserttype(fiberv, JANET_FIBER, st); 21180| 0| env->as.fiber = janet_unwrap_fiber(fiberv); ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 21181| | /* Negative offset indicates untrusted input */ 21182| 0| env->offset = -offset; 21183| 2.11k| } else { 21184| | /* Off stack variant */ 21185| 2.11k| if (length == 0) { ------------------ | Branch (21185:17): [True: 0, False: 2.11k] ------------------ 21186| 0| janet_panic("invalid funcenv length"); 21187| 0| } 21188| 2.11k| env->as.values = array_allocate(sizeof(Janet), length); 21189| 2.11k| if (!env->as.values) { ------------------ | Branch (21189:17): [True: 0, False: 2.11k] ------------------ 21190| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 21191| 0| } 21192| 2.11k| env->offset = 0; 21193| 26.1k| for (int32_t i = 0; i < length; i++) ------------------ | Branch (21193:33): [True: 24.0k, False: 2.11k] ------------------ 21194| 24.0k| data = unmarshal_one(st, data, env->as.values + i, flags); 21195| 2.11k| } 21196| 2.11k| env->length = length; 21197| 2.11k| *out = env; 21198| 2.11k| } 21199| 11.3k| return data; 21200| 11.3k|} janet.c:janet_asserttype: 21121| 264k|static void janet_asserttype(Janet x, JanetType t, UnmarshalState *st) { 21122| 264k| if (!janet_checktype(x, t)) { ------------------ | | 806| 264k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [True: 0, False: 264k] | | ------------------ | | 807| 264k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 264k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 264k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 264k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 264k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 264k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (21122:9): [True: 0, False: 264k] ------------------ 21123| |#ifdef JANET_MARSHAL_DEBUG 21124| | dump_reference_table(st); 21125| |#else 21126| 0| (void) st; 21127| 0|#endif 21128| 0| janet_panicf("expected type %T, got %v", 1 << t, x); 21129| 0| } 21130| 264k|} janet.c:janet_parser_checkdead: 27639| 23.5M|static void janet_parser_checkdead(JanetParser *parser) { 27640| 23.5M| if (parser->flag) janet_panic("parser is dead, cannot consume"); ------------------ | Branch (27640:9): [True: 0, False: 23.5M] ------------------ 27641| 23.5M| if (parser->error) janet_panic("parser has unchecked error, cannot consume"); ------------------ | Branch (27641:9): [True: 0, False: 23.5M] ------------------ 27642| 23.5M|} janet.c:delim_error: 27149| 70|static void delim_error(JanetParser *parser, size_t stack_index, char c, const char *msg) { 27150| 70| JanetParseState *s = parser->states + stack_index; 27151| 70| JanetBuffer *buffer = janet_buffer(40); 27152| 70| if (msg) { ------------------ | Branch (27152:9): [True: 70, False: 0] ------------------ 27153| 70| janet_buffer_push_cstring(buffer, msg); 27154| 70| } 27155| 70| if (c) { ------------------ | Branch (27155:9): [True: 70, False: 0] ------------------ 27156| 70| janet_buffer_push_u8(buffer, c); 27157| 70| } 27158| 70| if (stack_index > 0) { ------------------ | Branch (27158:9): [True: 3, False: 67] ------------------ 27159| 3| janet_buffer_push_cstring(buffer, ", "); 27160| 3| if (s->flags & PFLAG_PARENS) { ------------------ | |27085| 3|#define PFLAG_PARENS 0x400 ------------------ | Branch (27160:13): [True: 0, False: 3] ------------------ 27161| 0| janet_buffer_push_u8(buffer, '('); 27162| 3| } else if (s->flags & PFLAG_SQRBRACKETS) { ------------------ | |27086| 3|#define PFLAG_SQRBRACKETS 0x800 ------------------ | Branch (27162:20): [True: 0, False: 3] ------------------ 27163| 0| janet_buffer_push_u8(buffer, '['); 27164| 3| } else if (s->flags & PFLAG_CURLYBRACKETS) { ------------------ | |27087| 3|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ | Branch (27164:20): [True: 2, False: 1] ------------------ 27165| 2| janet_buffer_push_u8(buffer, '{'); 27166| 2| } else if (s->flags & PFLAG_STRING) { ------------------ | |27088| 1|#define PFLAG_STRING 0x2000 ------------------ | Branch (27166:20): [True: 0, False: 1] ------------------ 27167| 0| janet_buffer_push_u8(buffer, '"'); 27168| 1| } else if (s->flags & PFLAG_LONGSTRING) { ------------------ | |27089| 1|#define PFLAG_LONGSTRING 0x4000 ------------------ | Branch (27168:20): [True: 0, False: 1] ------------------ 27169| 0| int32_t i; 27170| 0| for (i = 0; i < s->argn; i++) { ------------------ | Branch (27170:25): [True: 0, False: 0] ------------------ 27171| 0| janet_buffer_push_u8(buffer, '`'); 27172| 0| } 27173| 0| } 27174| 3| janet_formatb(buffer, " opened at line %d, column %d", (int32_t) s->line, (int32_t) s->column); 27175| 3| } 27176| 70| parser->error = (const char *) janet_string(buffer->data, buffer->count); 27177| 70| parser->flag |= JANET_PARSER_GENERATED_ERROR; ------------------ | |26979| 70|#define JANET_PARSER_GENERATED_ERROR 0x2 ------------------ 27178| 70|} janet.c:pushstate: 27095| 10.0M|static void pushstate(JanetParser *p, Consumer consumer, int flags) { 27096| 10.0M| JanetParseState s; 27097| 10.0M| s.counter = 0; 27098| 10.0M| s.argn = 0; 27099| 10.0M| s.flags = flags; 27100| 10.0M| s.consumer = consumer; 27101| 10.0M| s.line = p->line; 27102| 10.0M| s.column = p->column; 27103| 10.0M| _pushstate(p, s); 27104| 10.0M|} janet.c:root: 27566| 10.7M|static int root(JanetParser *p, JanetParseState *state, uint8_t c) { 27567| 10.7M| switch (c) { 27568| 3.45M| default: ------------------ | Branch (27568:9): [True: 3.45M, False: 7.30M] ------------------ 27569| 3.45M| if (is_whitespace(c)) return 1; ------------------ | Branch (27569:17): [True: 777k, False: 2.67M] ------------------ 27570| 2.67M| if (!janet_is_symbol_char(c)) { ------------------ | Branch (27570:17): [True: 34, False: 2.67M] ------------------ 27571| 34| p->error = "unexpected character"; 27572| 34| return 1; 27573| 34| } 27574| 2.67M| pushstate(p, tokenchar, PFLAG_TOKEN); ------------------ | |27093| 2.67M|#define PFLAG_TOKEN 0x40000 ------------------ 27575| 2.67M| return 0; 27576| 231k| case '\'': ------------------ | Branch (27576:9): [True: 231k, False: 10.5M] ------------------ 27577| 1.25M| case ',': ------------------ | Branch (27577:9): [True: 1.02M, False: 9.73M] ------------------ 27578| 1.57M| case ';': ------------------ | Branch (27578:9): [True: 325k, False: 10.4M] ------------------ 27579| 2.14M| case '~': ------------------ | Branch (27579:9): [True: 571k, False: 10.1M] ------------------ 27580| 4.59M| case '|': ------------------ | Branch (27580:9): [True: 2.44M, False: 8.30M] ------------------ 27581| 4.59M| pushstate(p, root, PFLAG_READERMAC | c); ------------------ | |27090| 4.59M|#define PFLAG_READERMAC 0x8000 ------------------ 27582| 4.59M| return 1; 27583| 1.54M| case '"': ------------------ | Branch (27583:9): [True: 1.54M, False: 9.20M] ------------------ 27584| 1.54M| pushstate(p, stringchar, PFLAG_STRING); ------------------ | |27088| 1.54M|#define PFLAG_STRING 0x2000 ------------------ 27585| 1.54M| return 1; 27586| 1.82k| case '#': ------------------ | Branch (27586:9): [True: 1.82k, False: 10.7M] ------------------ 27587| 1.82k| pushstate(p, comment, PFLAG_COMMENT); ------------------ | |27092| 1.82k|#define PFLAG_COMMENT 0x20000 ------------------ 27588| 1.82k| return 1; 27589| 55.1k| case '@': ------------------ | Branch (27589:9): [True: 55.1k, False: 10.6M] ------------------ 27590| 55.1k| pushstate(p, atsign, PFLAG_ATSYM); ------------------ | |27091| 55.1k|#define PFLAG_ATSYM 0x10000 ------------------ 27591| 55.1k| return 1; 27592| 156k| case '`': ------------------ | Branch (27592:9): [True: 156k, False: 10.5M] ------------------ 27593| 156k| pushstate(p, longstring, PFLAG_LONGSTRING); ------------------ | |27089| 156k|#define PFLAG_LONGSTRING 0x4000 ------------------ 27594| 156k| return 1; 27595| 20.1k| case ')': ------------------ | Branch (27595:9): [True: 20.1k, False: 10.7M] ------------------ 27596| 21.2k| case ']': ------------------ | Branch (27596:9): [True: 1.02k, False: 10.7M] ------------------ 27597| 22.4k| case '}': { ------------------ | Branch (27597:9): [True: 1.26k, False: 10.7M] ------------------ 27598| 22.4k| Janet ds; 27599| 22.4k| if (p->statecount == 1) { ------------------ | Branch (27599:17): [True: 67, False: 22.4k] ------------------ 27600| 67| delim_error(p, 0, c, "unexpected closing delimiter "); 27601| 67| return 1; 27602| 67| } 27603| 22.4k| if ((c == ')' && (state->flags & PFLAG_PARENS)) || ------------------ | |27085| 20.1k|#define PFLAG_PARENS 0x400 ------------------ | Branch (27603:18): [True: 20.1k, False: 2.29k] | Branch (27603:30): [True: 20.1k, False: 3] ------------------ 27604| 21.1k| (c == ']' && (state->flags & PFLAG_SQRBRACKETS))) { ------------------ | |27086| 1.02k|#define PFLAG_SQRBRACKETS 0x800 ------------------ | Branch (27604:22): [True: 1.02k, False: 1.26k] | Branch (27604:34): [True: 1.02k, False: 0] ------------------ 27605| 21.1k| if (state->flags & PFLAG_ATSYM) { ------------------ | |27091| 21.1k|#define PFLAG_ATSYM 0x10000 ------------------ | Branch (27605:21): [True: 273, False: 20.8k] ------------------ 27606| 273| ds = close_array(p, state); 27607| 20.8k| } else { 27608| 20.8k| ds = close_tuple(p, state, c == ']' ? JANET_TUPLE_FLAG_BRACKETCTOR : 0); ------------------ | | 1798| 758|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (27608:48): [True: 758, False: 20.1k] ------------------ 27609| 20.8k| } 27610| 21.1k| } else if (c == '}' && (state->flags & PFLAG_CURLYBRACKETS)) { ------------------ | |27087| 1.26k|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ | Branch (27610:24): [True: 1.26k, False: 3] | Branch (27610:36): [True: 1.26k, False: 0] ------------------ 27611| 1.26k| if (state->argn & 1) { ------------------ | Branch (27611:21): [True: 1, False: 1.26k] ------------------ 27612| 1| p->error = "struct and table literals expect even number of arguments"; 27613| 1| return 1; 27614| 1| } 27615| 1.26k| if (state->flags & PFLAG_ATSYM) { ------------------ | |27091| 1.26k|#define PFLAG_ATSYM 0x10000 ------------------ | Branch (27615:21): [True: 1.01k, False: 253] ------------------ 27616| 1.01k| ds = close_table(p, state); 27617| 1.01k| } else { 27618| 253| ds = close_struct(p, state); 27619| 253| } 27620| 1.26k| } else { 27621| 3| delim_error(p, p->statecount - 1, c, "mismatched delimiter "); 27622| 3| return 1; 27623| 3| } 27624| 22.4k| popstate(p, ds); 27625| 22.4k| } 27626| 0| return 1; 27627| 654k| case '(': ------------------ | Branch (27627:9): [True: 654k, False: 10.0M] ------------------ 27628| 654k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS); ------------------ | |27083| 654k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS); ------------------ | |27085| 654k|#define PFLAG_PARENS 0x400 ------------------ 27629| 654k| return 1; 27630| 266k| case '[': ------------------ | Branch (27630:9): [True: 266k, False: 10.4M] ------------------ 27631| 266k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS); ------------------ | |27083| 266k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS); ------------------ | |27086| 266k|#define PFLAG_SQRBRACKETS 0x800 ------------------ 27632| 266k| return 1; 27633| 260| case '{': ------------------ | Branch (27633:9): [True: 260, False: 10.7M] ------------------ 27634| 260| pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS); ------------------ | |27083| 260|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS); ------------------ | |27087| 260|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ 27635| 260| return 1; 27636| 10.7M| } 27637| 10.7M|} janet.c:is_whitespace: 26982| 3.45M|static int is_whitespace(uint8_t c) { 26983| 3.45M| return c == ' ' ------------------ | Branch (26983:12): [True: 15.7k, False: 3.43M] ------------------ 26984| 3.43M| || c == '\t' ------------------ | Branch (26984:15): [True: 16.4k, False: 3.41M] ------------------ 26985| 3.41M| || c == '\n' ------------------ | Branch (26985:15): [True: 102k, False: 3.31M] ------------------ 26986| 3.31M| || c == '\r' ------------------ | Branch (26986:15): [True: 239k, False: 3.07M] ------------------ 26987| 3.07M| || c == '\0' ------------------ | Branch (26987:15): [True: 401k, False: 2.67M] ------------------ 26988| 2.67M| || c == '\v' ------------------ | Branch (26988:15): [True: 1.15k, False: 2.67M] ------------------ 26989| 2.67M| || c == '\f'; ------------------ | Branch (26989:15): [True: 794, False: 2.67M] ------------------ 26990| 3.45M|} janet.c:stringchar: 27361| 6.20M|static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c) { 27362| | /* Enter escape */ 27363| 6.20M| if (c == '\\') { ------------------ | Branch (27363:9): [True: 10.0k, False: 6.19M] ------------------ 27364| 10.0k| state->consumer = escape1; 27365| 10.0k| return 1; 27366| 10.0k| } 27367| | /* String end */ 27368| 6.19M| if (c == '"') { ------------------ | Branch (27368:9): [True: 1.55M, False: 4.64M] ------------------ 27369| 1.55M| return stringend(p, state); 27370| 1.55M| } 27371| | /* normal char */ 27372| 4.64M| if (c != '\n' && c != '\r') ------------------ | Branch (27372:9): [True: 4.63M, False: 11.4k] | Branch (27372:22): [True: 4.58M, False: 47.6k] ------------------ 27373| 4.58M| push_buf(p, c); 27374| 4.64M| return 1; 27375| 6.19M|} janet.c:escape1: 27276| 10.0k|static int escape1(JanetParser *p, JanetParseState *state, uint8_t c) { 27277| 10.0k| int e = checkescape(c); 27278| 10.0k| if (e < 0) { ------------------ | Branch (27278:9): [True: 0, False: 10.0k] ------------------ 27279| 0| p->error = "invalid string escape sequence"; 27280| 0| return 1; 27281| 0| } 27282| 10.0k| if (c == 'x') { ------------------ | Branch (27282:9): [True: 0, False: 10.0k] ------------------ 27283| 0| state->counter = 2; 27284| 0| state->argn = 0; 27285| 0| state->consumer = escapeh; 27286| 10.0k| } else if (c == 'u' || c == 'U') { ------------------ | Branch (27286:16): [True: 8, False: 10.0k] | Branch (27286:28): [True: 3.68k, False: 6.39k] ------------------ 27287| 3.68k| state->counter = c == 'u' ? 4 : 6; ------------------ | Branch (27287:26): [True: 8, False: 3.68k] ------------------ 27288| 3.68k| state->argn = 0; 27289| 3.68k| state->consumer = escapeu; 27290| 6.39k| } else { 27291| 6.39k| push_buf(p, (uint8_t) e); 27292| 6.39k| state->consumer = stringchar; 27293| 6.39k| } 27294| 10.0k| return 1; 27295| 10.0k|} janet.c:checkescape: 27180| 10.0k|static int checkescape(uint8_t c) { 27181| 10.0k| switch (c) { 27182| 0| default: ------------------ | Branch (27182:9): [True: 0, False: 10.0k] ------------------ 27183| 0| return -1; 27184| 0| case 'x': ------------------ | Branch (27184:9): [True: 0, False: 10.0k] ------------------ 27185| 8| case 'u': ------------------ | Branch (27185:9): [True: 8, False: 10.0k] ------------------ 27186| 3.68k| case 'U': ------------------ | Branch (27186:9): [True: 3.68k, False: 6.40k] ------------------ 27187| 3.68k| return 1; 27188| 505| case 'n': ------------------ | Branch (27188:9): [True: 505, False: 9.58k] ------------------ 27189| 505| return '\n'; 27190| 0| case 't': ------------------ | Branch (27190:9): [True: 0, False: 10.0k] ------------------ 27191| 0| return '\t'; 27192| 504| case 'r': ------------------ | Branch (27192:9): [True: 504, False: 9.58k] ------------------ 27193| 504| return '\r'; 27194| 0| case '0': ------------------ | Branch (27194:9): [True: 0, False: 10.0k] ------------------ 27195| 0| return '\0'; 27196| 0| case 'z': ------------------ | Branch (27196:9): [True: 0, False: 10.0k] ------------------ 27197| 0| return '\0'; 27198| 0| case 'f': ------------------ | Branch (27198:9): [True: 0, False: 10.0k] ------------------ 27199| 0| return '\f'; 27200| 0| case 'v': ------------------ | Branch (27200:9): [True: 0, False: 10.0k] ------------------ 27201| 0| return '\v'; 27202| 0| case 'a': ------------------ | Branch (27202:9): [True: 0, False: 10.0k] ------------------ 27203| 0| return '\a'; 27204| 367| case 'b': ------------------ | Branch (27204:9): [True: 367, False: 9.71k] ------------------ 27205| 367| return '\b'; 27206| 0| case '\'': ------------------ | Branch (27206:9): [True: 0, False: 10.0k] ------------------ 27207| 0| return '\''; 27208| 1| case '?': ------------------ | Branch (27208:9): [True: 1, False: 10.0k] ------------------ 27209| 1| return '?'; 27210| 0| case 'e': ------------------ | Branch (27210:9): [True: 0, False: 10.0k] ------------------ 27211| 0| return 27; 27212| 5.01k| case '"': ------------------ | Branch (27212:9): [True: 5.01k, False: 5.06k] ------------------ 27213| 5.01k| return '"'; 27214| 0| case '\\': ------------------ | Branch (27214:9): [True: 0, False: 10.0k] ------------------ 27215| 0| return '\\'; 27216| 10.0k| } 27217| 10.0k|} janet.c:to_hex: 27045| 22.1k|static int to_hex(uint8_t c) { 27046| 22.1k| if (c >= '0' && c <= '9') { ------------------ | Branch (27046:9): [True: 22.1k, False: 0] | Branch (27046:21): [True: 15.3k, False: 6.78k] ------------------ 27047| 15.3k| return c - '0'; 27048| 15.3k| } else if (c >= 'A' && c <= 'F') { ------------------ | Branch (27048:16): [True: 6.77k, False: 1] | Branch (27048:28): [True: 4.06k, False: 2.71k] ------------------ 27049| 4.06k| return 10 + c - 'A'; 27050| 4.06k| } else if (c >= 'a' && c <= 'f') { ------------------ | Branch (27050:16): [True: 2.71k, False: 2] | Branch (27050:28): [True: 2.71k, False: 0] ------------------ 27051| 2.71k| return 10 + c - 'a'; 27052| 2.71k| } else { 27053| 2| return -1; 27054| 2| } 27055| 22.1k|} janet.c:escapeu: 27256| 22.1k|static int escapeu(JanetParser *p, JanetParseState *state, uint8_t c) { 27257| 22.1k| int digit = to_hex(c); 27258| 22.1k| if (digit < 0) { ------------------ | Branch (27258:9): [True: 2, False: 22.1k] ------------------ 27259| 2| p->error = "invalid hex digit in unicode escape"; 27260| 2| return 1; 27261| 2| } 27262| 22.1k| state->argn = (state->argn << 4) + digit; 27263| 22.1k| state->counter--; 27264| 22.1k| if (!state->counter) { ------------------ | Branch (27264:9): [True: 3.68k, False: 18.4k] ------------------ 27265| 3.68k| if (state->argn > 0x10FFFF) { ------------------ | Branch (27265:13): [True: 0, False: 3.68k] ------------------ 27266| 0| p->error = "invalid unicode codepoint"; 27267| 0| return 1; 27268| 0| } 27269| 3.68k| write_codepoint(p, state->argn); 27270| 3.68k| state->argn = 0; 27271| 3.68k| state->consumer = stringchar; 27272| 3.68k| } 27273| 22.1k| return 1; 27274| 22.1k|} janet.c:write_codepoint: 27222| 3.68k|static void write_codepoint(JanetParser *p, int32_t codepoint) { 27223| 3.68k| if (codepoint <= 0x7F) { ------------------ | Branch (27223:9): [True: 0, False: 3.68k] ------------------ 27224| 0| push_buf(p, (uint8_t) codepoint); 27225| 3.68k| } else if (codepoint <= 0x7FF) { ------------------ | Branch (27225:16): [True: 2.33k, False: 1.35k] ------------------ 27226| 2.33k| push_buf(p, (uint8_t)((codepoint >> 6) & 0x1F) | 0xC0); 27227| 2.33k| push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); 27228| 2.33k| } else if (codepoint <= 0xFFFF) { ------------------ | Branch (27228:16): [True: 2, False: 1.35k] ------------------ 27229| 2| push_buf(p, (uint8_t)((codepoint >> 12) & 0x0F) | 0xE0); 27230| 2| push_buf(p, (uint8_t)((codepoint >> 6) & 0x3F) | 0x80); 27231| 2| push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); 27232| 1.35k| } else { 27233| 1.35k| push_buf(p, (uint8_t)((codepoint >> 18) & 0x07) | 0xF0); 27234| 1.35k| push_buf(p, (uint8_t)((codepoint >> 12) & 0x3F) | 0x80); 27235| 1.35k| push_buf(p, (uint8_t)((codepoint >> 6) & 0x3F) | 0x80); 27236| 1.35k| push_buf(p, (uint8_t)((codepoint >> 0) & 0x3F) | 0x80); 27237| 1.35k| } 27238| 3.68k|} janet.c:stringend: 27297| 1.70M|static int stringend(JanetParser *p, JanetParseState *state) { 27298| 1.70M| Janet ret; 27299| 1.70M| uint8_t *bufstart = p->buf; 27300| 1.70M| int32_t buflen = (int32_t) p->bufcount; 27301| 1.70M| if (state->flags & PFLAG_LONGSTRING) { ------------------ | |27089| 1.70M|#define PFLAG_LONGSTRING 0x4000 ------------------ | Branch (27301:9): [True: 156k, False: 1.55M] ------------------ 27302| | /* Post process to remove leading whitespace */ 27303| 156k| JanetParseState top = p->states[p->statecount - 1]; 27304| 156k| int32_t indent_col = (int32_t) top.column - 1; 27305| 156k| uint8_t *r = bufstart, *end = r + buflen; 27306| | /* Unless there are only spaces before EOLs, disable reindenting */ 27307| 156k| int reindent = 1; 27308| 2.24M| while (reindent && (r < end)) { ------------------ | Branch (27308:16): [True: 2.24M, False: 102] | Branch (27308:28): [True: 2.09M, False: 156k] ------------------ 27309| 2.09M| if (*r++ == '\n') { ------------------ | Branch (27309:17): [True: 2.82k, False: 2.08M] ------------------ 27310| 2.82k| for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++) { ------------------ | Branch (27310:37): [True: 2.17k, False: 644] | Branch (27310:50): [True: 1.52k, False: 649] | Branch (27310:66): [True: 154, False: 1.37k] ------------------ 27311| 154| if (*r != ' ') { ------------------ | Branch (27311:25): [True: 154, False: 0] ------------------ 27312| 154| reindent = 0; 27313| 154| break; 27314| 154| } 27315| 154| } 27316| 2.82k| if ((r + 1) < end && *r == '\r' && *(r + 1) == '\n') reindent = 1; ------------------ | Branch (27316:21): [True: 2.13k, False: 690] | Branch (27316:38): [True: 587, False: 1.54k] | Branch (27316:52): [True: 403, False: 184] ------------------ 27317| 2.82k| } 27318| 2.09M| } 27319| | /* Now reindent if able */ 27320| 156k| if (reindent) { ------------------ | Branch (27320:13): [True: 156k, False: 102] ------------------ 27321| 156k| uint8_t *w = bufstart; 27322| 156k| r = bufstart; 27323| 2.07M| while (r < end) { ------------------ | Branch (27323:20): [True: 1.92M, False: 156k] ------------------ 27324| 1.92M| if (*r == '\n') { ------------------ | Branch (27324:21): [True: 2.63k, False: 1.91M] ------------------ 27325| 2.63k| *w++ = *r++; 27326| 2.68k| for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++); ------------------ | Branch (27326:41): [True: 2.04k, False: 644] | Branch (27326:54): [True: 1.42k, False: 617] | Branch (27326:70): [True: 52, False: 1.37k] ------------------ 27327| 2.63k| if ((r + 1) < end && *r == '\r' && *(r + 1) == '\n') *w++ = *r++; ------------------ | Branch (27327:25): [True: 1.89k, False: 737] | Branch (27327:42): [True: 534, False: 1.36k] | Branch (27327:56): [True: 351, False: 183] ------------------ 27328| 1.91M| } else { 27329| 1.91M| *w++ = *r++; 27330| 1.91M| } 27331| 1.92M| } 27332| 156k| buflen = (int32_t)(w - bufstart); 27333| 156k| } 27334| | /* Check for leading EOL so we can remove it */ 27335| 156k| if (buflen > 1 && bufstart[0] == '\r' && bufstart[1] == '\n') { /* Windows EOL */ ------------------ | Branch (27335:13): [True: 32.1k, False: 124k] | Branch (27335:27): [True: 295, False: 31.8k] | Branch (27335:50): [True: 156, False: 139] ------------------ 27336| 156| buflen = buflen - 2; 27337| 156| bufstart = bufstart + 2; 27338| 156k| } else if (buflen > 0 && bufstart[0] == '\n') { /* Unix EOL */ ------------------ | Branch (27338:20): [True: 156k, False: 0] | Branch (27338:34): [True: 351, False: 155k] ------------------ 27339| 351| buflen--; 27340| 351| bufstart++; 27341| 351| } 27342| | /* Check for trailing EOL so we can remove it */ 27343| 156k| if (buflen > 1 && bufstart[buflen - 2] == '\r' && bufstart[buflen - 1] == '\n') { /* Windows EOL */ ------------------ | Branch (27343:13): [True: 31.9k, False: 124k] | Branch (27343:27): [True: 691, False: 31.2k] | Branch (27343:59): [True: 321, False: 370] ------------------ 27344| 321| buflen = buflen - 2; 27345| 156k| } else if (buflen > 0 && bufstart[buflen - 1] == '\n') { /* Unix EOL */ ------------------ | Branch (27345:20): [True: 155k, False: 270] | Branch (27345:34): [True: 91, False: 155k] ------------------ 27346| 91| buflen--; 27347| 91| } 27348| 156k| } 27349| 1.70M| if (state->flags & PFLAG_BUFFER) { ------------------ | |27084| 1.70M|#define PFLAG_BUFFER 0x200 ------------------ | Branch (27349:9): [True: 4.12k, False: 1.70M] ------------------ 27350| 4.12k| JanetBuffer *b = janet_buffer(buflen); 27351| 4.12k| janet_buffer_push_bytes(b, bufstart, buflen); 27352| 4.12k| ret = janet_wrap_buffer(b); ------------------ | | 847| 4.12k|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 4.12k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 4.12k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.12k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27353| 1.70M| } else { 27354| 1.70M| ret = janet_wrap_string(janet_string(bufstart, buflen)); ------------------ | | 848| 1.70M|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 1.70M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.70M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.70M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27355| 1.70M| } 27356| 1.70M| p->bufcount = 0; 27357| 1.70M| popstate(p, ret); 27358| 1.70M| return 1; 27359| 1.70M|} janet.c:comment: 27443| 186k|static int comment(JanetParser *p, JanetParseState *state, uint8_t c) { 27444| 186k| (void) state; 27445| 186k| if (c == '\n') { ------------------ | Branch (27445:9): [True: 1.82k, False: 184k] ------------------ 27446| 1.82k| p->statecount--; 27447| 1.82k| p->bufcount = 0; 27448| 184k| } else { 27449| 184k| push_buf(p, c); 27450| 184k| } 27451| 186k| return 1; 27452| 186k|} janet.c:atsign: 27538| 55.1k|static int atsign(JanetParser *p, JanetParseState *state, uint8_t c) { 27539| 55.1k| (void) state; 27540| 55.1k| p->statecount--; 27541| 55.1k| switch (c) { 27542| 1.01k| case '{': ------------------ | Branch (27542:9): [True: 1.01k, False: 54.1k] ------------------ 27543| 1.01k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); ------------------ | |27083| 1.01k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); ------------------ | |27087| 1.01k|#define PFLAG_CURLYBRACKETS 0x1000 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM); ------------------ | |27091| 1.01k|#define PFLAG_ATSYM 0x10000 ------------------ 27544| 1.01k| return 1; 27545| 4.05k| case '"': ------------------ | Branch (27545:9): [True: 4.05k, False: 51.1k] ------------------ 27546| 4.05k| pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING); ------------------ | |27084| 4.05k|#define PFLAG_BUFFER 0x200 ------------------ pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING); ------------------ | |27088| 4.05k|#define PFLAG_STRING 0x2000 ------------------ 27547| 4.05k| return 1; 27548| 72| case '`': ------------------ | Branch (27548:9): [True: 72, False: 55.1k] ------------------ 27549| 72| pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING); ------------------ | |27084| 72|#define PFLAG_BUFFER 0x200 ------------------ pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING); ------------------ | |27089| 72|#define PFLAG_LONGSTRING 0x4000 ------------------ 27550| 72| return 1; 27551| 269| case '[': ------------------ | Branch (27551:9): [True: 269, False: 54.9k] ------------------ 27552| 269| pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); ------------------ | |27083| 269|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); ------------------ | |27086| 269|#define PFLAG_SQRBRACKETS 0x800 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM); ------------------ | |27091| 269|#define PFLAG_ATSYM 0x10000 ------------------ 27553| 269| return 1; 27554| 48.2k| case '(': ------------------ | Branch (27554:9): [True: 48.2k, False: 6.94k] ------------------ 27555| 48.2k| pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); ------------------ | |27083| 48.2k|#define PFLAG_CONTAINER 0x100 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); ------------------ | |27085| 48.2k|#define PFLAG_PARENS 0x400 ------------------ pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM); ------------------ | |27091| 48.2k|#define PFLAG_ATSYM 0x10000 ------------------ 27556| 48.2k| return 1; 27557| 1.53k| default: ------------------ | Branch (27557:9): [True: 1.53k, False: 53.6k] ------------------ 27558| 1.53k| break; 27559| 55.1k| } 27560| 1.53k| pushstate(p, tokenchar, PFLAG_TOKEN); ------------------ | |27093| 1.53k|#define PFLAG_TOKEN 0x40000 ------------------ 27561| 1.53k| push_buf(p, '@'); /* Push the leading at-sign that was dropped */ 27562| 1.53k| return 0; 27563| 55.1k|} janet.c:longstring: 27494| 2.62M|static int longstring(JanetParser *p, JanetParseState *state, uint8_t c) { 27495| 2.62M| if (state->flags & PFLAG_INSTRING) { ------------------ | |27492| 2.62M|#define PFLAG_INSTRING 0x100000 ------------------ | Branch (27495:9): [True: 2.27M, False: 343k] ------------------ 27496| | /* We are inside the long string */ 27497| 2.27M| if (c == '`') { ------------------ | Branch (27497:13): [True: 186k, False: 2.09M] ------------------ 27498| 186k| state->flags |= PFLAG_END_CANDIDATE; ------------------ | |27493| 186k|#define PFLAG_END_CANDIDATE 0x200000 ------------------ 27499| 186k| state->flags &= ~PFLAG_INSTRING; ------------------ | |27492| 186k|#define PFLAG_INSTRING 0x100000 ------------------ 27500| 186k| state->counter = 1; /* Use counter to keep track of number of '=' seen */ 27501| 186k| return 1; 27502| 186k| } 27503| 2.09M| push_buf(p, c); 27504| 2.09M| return 1; 27505| 2.27M| } else if (state->flags & PFLAG_END_CANDIDATE) { ------------------ | |27493| 343k|#define PFLAG_END_CANDIDATE 0x200000 ------------------ | Branch (27505:16): [True: 186k, False: 156k] ------------------ 27506| 186k| int i; 27507| | /* We are checking a potential end of the string */ 27508| 186k| if (state->counter == state->argn) { ------------------ | Branch (27508:13): [True: 156k, False: 29.9k] ------------------ 27509| 156k| stringend(p, state); 27510| 156k| return 0; 27511| 156k| } 27512| 29.9k| if (c == '`' && state->counter < state->argn) { ------------------ | Branch (27512:13): [True: 335, False: 29.6k] | Branch (27512:25): [True: 335, False: 0] ------------------ 27513| 335| state->counter++; 27514| 335| return 1; 27515| 335| } 27516| | /* Failed end candidate */ 27517| 59.2k| for (i = 0; i < state->counter; i++) { ------------------ | Branch (27517:21): [True: 29.6k, False: 29.6k] ------------------ 27518| 29.6k| push_buf(p, '`'); 27519| 29.6k| } 27520| 29.6k| push_buf(p, c); 27521| 29.6k| state->counter = 0; 27522| 29.6k| state->flags &= ~PFLAG_END_CANDIDATE; ------------------ | |27493| 29.6k|#define PFLAG_END_CANDIDATE 0x200000 ------------------ 27523| 29.6k| state->flags |= PFLAG_INSTRING; ------------------ | |27492| 29.6k|#define PFLAG_INSTRING 0x100000 ------------------ 27524| 29.6k| return 1; 27525| 156k| } else { 27526| | /* We are at beginning of string */ 27527| 156k| state->argn++; 27528| 156k| if (c != '`') { ------------------ | Branch (27528:13): [True: 156k, False: 444] ------------------ 27529| 156k| state->flags |= PFLAG_INSTRING; ------------------ | |27492| 156k|#define PFLAG_INSTRING 0x100000 ------------------ 27530| 156k| push_buf(p, c); 27531| 156k| } 27532| 156k| return 1; 27533| 156k| } 27534| 2.62M|} janet.c:close_array: 27462| 273|static Janet close_array(JanetParser *p, JanetParseState *state) { 27463| 273| JanetArray *array = janet_array(state->argn); 27464| 27.4k| for (int32_t i = state->argn - 1; i >= 0; i--) ------------------ | Branch (27464:39): [True: 27.2k, False: 273] ------------------ 27465| 27.2k| array->data[i] = p->args[--p->argcount]; 27466| 273| array->count = state->argn; 27467| 273| return janet_wrap_array(array); ------------------ | | 845| 273|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 273| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 273|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 273|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27468| 273|} janet.c:close_tuple: 27454| 20.8k|static Janet close_tuple(JanetParser *p, JanetParseState *state, int32_t flag) { 27455| 20.8k| Janet *ret = janet_tuple_begin(state->argn); 27456| 20.8k| janet_tuple_flag(ret) |= flag; ------------------ | | 1806| 20.8k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 20.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27457| 1.90M| for (int32_t i = state->argn - 1; i >= 0; i--) ------------------ | Branch (27457:39): [True: 1.88M, False: 20.8k] ------------------ 27458| 1.88M| ret[i] = p->args[--p->argcount]; 27459| 20.8k| return janet_wrap_tuple(janet_tuple_end(ret)); ------------------ | | 843| 20.8k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 20.8k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 20.8k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 20.8k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27460| 20.8k|} janet.c:close_table: 27481| 1.01k|static Janet close_table(JanetParser *p, JanetParseState *state) { 27482| 1.01k| JanetTable *table = janet_table(state->argn >> 1); 27483| 2.68k| for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) { ------------------ | Branch (27483:48): [True: 1.67k, False: 1.01k] ------------------ 27484| 1.67k| Janet key = p->args[i]; 27485| 1.67k| Janet value = p->args[i + 1]; 27486| 1.67k| janet_table_put(table, key, value); 27487| 1.67k| } 27488| 1.01k| p->argcount -= state->argn; 27489| 1.01k| return janet_wrap_table(table); ------------------ | | 846| 1.01k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 1.01k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.01k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.01k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27490| 1.01k|} janet.c:close_struct: 27470| 253|static Janet close_struct(JanetParser *p, JanetParseState *state) { 27471| 253| JanetKV *st = janet_struct_begin(state->argn >> 1); 27472| 596k| for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) { ------------------ | Branch (27472:48): [True: 595k, False: 253] ------------------ 27473| 595k| Janet key = p->args[i]; 27474| 595k| Janet value = p->args[i + 1]; 27475| 595k| janet_struct_put(st, key, value); 27476| 595k| } 27477| 253| p->argcount -= state->argn; 27478| 253| return janet_wrap_struct(janet_struct_end(st)); ------------------ | | 842| 253|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 253| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 253|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 253|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27479| 253|} janet.c:popstate: 27106| 4.40M|static void popstate(JanetParser *p, Janet val) { 27107| 8.97M| for (;;) { 27108| 8.97M| JanetParseState top = p->states[--p->statecount]; 27109| 8.97M| JanetParseState *newtop = p->states + p->statecount - 1; 27110| | /* Source mapping info */ 27111| 8.97M| if (janet_checktype(val, JANET_TUPLE)) { ------------------ | | 806| 8.97M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.58M, False: 4.38M] | | | Branch (806:6): [Folded, False: 8.97M] | | ------------------ | | 807| 8.97M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 8.97M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 8.97M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 8.97M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 8.97M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.97M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27112| 4.58M| janet_tuple_sm_line(janet_unwrap_tuple(val)) = (int32_t) top.line; ------------------ | | 1804| 4.58M|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 4.58M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27113| 4.58M| janet_tuple_sm_column(janet_unwrap_tuple(val)) = (int32_t) top.column; ------------------ | | 1805| 4.58M|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 4.58M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27114| 4.58M| } 27115| 8.97M| if (newtop->flags & PFLAG_CONTAINER) { ------------------ | |27083| 8.97M|#define PFLAG_CONTAINER 0x100 ------------------ | Branch (27115:13): [True: 4.40M, False: 4.56M] ------------------ 27116| 4.40M| newtop->argn++; 27117| | /* Keep track of number of values in the root state */ 27118| 4.40M| if (p->statecount == 1) { ------------------ | Branch (27118:17): [True: 57.2k, False: 4.34M] ------------------ 27119| 57.2k| p->pending++; 27120| | /* Root items are always wrapped in a tuple for source map info. */ 27121| 57.2k| const Janet *tup = janet_tuple_n(&val, 1); 27122| 57.2k| janet_tuple_sm_line(tup) = (int32_t) top.line; ------------------ | | 1804| 57.2k|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 57.2k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27123| 57.2k| janet_tuple_sm_column(tup) = (int32_t) top.column; ------------------ | | 1805| 57.2k|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 57.2k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27124| 57.2k| val = janet_wrap_tuple(tup); ------------------ | | 843| 57.2k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 57.2k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 57.2k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 57.2k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27125| 57.2k| } 27126| 4.40M| push_arg(p, val); 27127| 4.40M| return; 27128| 4.56M| } else if (newtop->flags & PFLAG_READERMAC) { ------------------ | |27090| 4.56M|#define PFLAG_READERMAC 0x8000 ------------------ | Branch (27128:20): [True: 4.56M, False: 0] ------------------ 27129| 4.56M| Janet *t = janet_tuple_begin(2); 27130| 4.56M| int c = newtop->flags & 0xFF; 27131| 4.56M| const char *which = 27132| 4.56M| (c == '\'') ? "quote" : ------------------ | Branch (27132:17): [True: 231k, False: 4.33M] ------------------ 27133| 4.56M| (c == ',') ? "unquote" : ------------------ | Branch (27133:17): [True: 1.02M, False: 3.31M] ------------------ 27134| 4.33M| (c == ';') ? "splice" : ------------------ | Branch (27134:17): [True: 325k, False: 2.99M] ------------------ 27135| 3.31M| (c == '|') ? "short-fn" : ------------------ | Branch (27135:17): [True: 2.44M, False: 548k] ------------------ 27136| 2.99M| (c == '~') ? "quasiquote" : ""; ------------------ | Branch (27136:17): [True: 548k, False: 0] ------------------ 27137| 4.56M| t[0] = janet_csymbolv(which); ------------------ | | 1837| 4.56M|#define janet_csymbolv(cstr) janet_wrap_symbol(janet_csymbol(cstr)) | | ------------------ | | | | 849| 4.56M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 4.56M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 4.56M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 4.56M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27138| 4.56M| t[1] = val; 27139| | /* Quote source mapping info */ 27140| 4.56M| janet_tuple_sm_line(t) = (int32_t) newtop->line; ------------------ | | 1804| 4.56M|#define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line) | | ------------------ | | | | 1800| 4.56M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27141| 4.56M| janet_tuple_sm_column(t) = (int32_t) newtop->column; ------------------ | | 1805| 4.56M|#define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column) | | ------------------ | | | | 1800| 4.56M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 27142| 4.56M| val = janet_wrap_tuple(janet_tuple_end(t)); ------------------ | | 843| 4.56M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 4.56M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 4.56M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.56M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27143| 4.56M| } else { 27144| 0| return; 27145| 0| } 27146| 8.97M| } 27147| 4.40M|} janet.c:tokenchar: 27390| 9.21M|static int tokenchar(JanetParser *p, JanetParseState *state, uint8_t c) { 27391| 9.21M| Janet ret; 27392| 9.21M| double numval; 27393| 9.21M| int32_t blen; 27394| 9.21M| if (janet_is_symbol_char(c)) { ------------------ | Branch (27394:9): [True: 6.54M, False: 2.67M] ------------------ 27395| 6.54M| push_buf(p, (uint8_t) c); 27396| 6.54M| if (c > 127) state->argn = 1; /* Use to indicate non ascii */ ------------------ | Branch (27396:13): [True: 11.1k, False: 6.53M] ------------------ 27397| 6.54M| return 1; 27398| 6.54M| } 27399| | /* Token finished */ 27400| 2.67M| blen = (int32_t) p->bufcount; 27401| 2.67M| int start_dig = p->buf[0] >= '0' && p->buf[0] <= '9'; ------------------ | Branch (27401:21): [True: 1.54M, False: 1.12M] | Branch (27401:41): [True: 706k, False: 843k] ------------------ 27402| 2.67M| int start_num = start_dig || p->buf[0] == '-' || p->buf[0] == '+' || p->buf[0] == '.'; ------------------ | Branch (27402:21): [True: 706k, False: 1.96M] | Branch (27402:34): [True: 493k, False: 1.47M] | Branch (27402:54): [True: 148k, False: 1.32M] | Branch (27402:74): [True: 183k, False: 1.14M] ------------------ 27403| 2.67M| if (p->buf[0] == ':') { ------------------ | Branch (27403:9): [True: 6.30k, False: 2.66M] ------------------ 27404| | /* Don't do full utf-8 check unless we have seen non ascii characters. */ 27405| 6.30k| int valid = (!state->argn) || janet_valid_utf8(p->buf + 1, blen - 1); ------------------ | Branch (27405:21): [True: 6.29k, False: 7] | Branch (27405:39): [True: 6, False: 1] ------------------ 27406| 6.30k| if (!valid) { ------------------ | Branch (27406:13): [True: 1, False: 6.29k] ------------------ 27407| 1| p->error = "invalid utf-8 in keyword"; 27408| 1| return 0; 27409| 1| } 27410| 6.29k| ret = janet_keywordv(p->buf + 1, blen - 1); ------------------ | | 1842| 6.29k|#define janet_keywordv(str, len) janet_wrap_keyword(janet_keyword((str), (len))) | | ------------------ | | | | 850| 6.29k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 6.29k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 6.29k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 6.29k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27411| 6.29k|#ifdef JANET_INT_TYPES 27412| 2.66M| } else if (start_num && !janet_scan_numeric(p->buf, blen, &ret)) { ------------------ | Branch (27412:16): [True: 1.53M, False: 1.13M] | Branch (27412:29): [True: 810k, False: 722k] ------------------ 27413| 810k| (void) numval; 27414| |#else 27415| | } else if (start_num && !janet_scan_number(p->buf, blen, &numval)) { 27416| | ret = janet_wrap_number(numval); 27417| |#endif 27418| 1.85M| } else if (!check_str_const("nil", p->buf, blen)) { ------------------ | Branch (27418:16): [True: 476, False: 1.85M] ------------------ 27419| 476| ret = janet_wrap_nil(); ------------------ | | 831| 476|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 476| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 476|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 476|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27420| 1.85M| } else if (!check_str_const("false", p->buf, blen)) { ------------------ | Branch (27420:16): [True: 12, False: 1.85M] ------------------ 27421| 12| ret = janet_wrap_false(); ------------------ | | 833| 12|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 12| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 12|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 12|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27422| 1.85M| } else if (!check_str_const("true", p->buf, blen)) { ------------------ | Branch (27422:16): [True: 13, False: 1.85M] ------------------ 27423| 13| ret = janet_wrap_true(); ------------------ | | 832| 13|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 13| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 13|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 13|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27424| 1.85M| } else { 27425| 1.85M| if (start_dig) { ------------------ | Branch (27425:13): [True: 11, False: 1.85M] ------------------ 27426| 11| p->error = "symbol literal cannot start with a digit"; 27427| 11| return 0; 27428| 1.85M| } else { 27429| | /* Don't do full utf-8 check unless we have seen non ascii characters. */ 27430| 1.85M| int valid = (!state->argn) || janet_valid_utf8(p->buf, blen); ------------------ | Branch (27430:25): [True: 1.85M, False: 2.85k] | Branch (27430:43): [True: 2.79k, False: 60] ------------------ 27431| 1.85M| if (!valid) { ------------------ | Branch (27431:17): [True: 60, False: 1.85M] ------------------ 27432| 60| p->error = "invalid utf-8 in symbol"; 27433| 60| return 0; 27434| 60| } 27435| 1.85M| ret = janet_symbolv(p->buf, blen); ------------------ | | 1836| 1.85M|#define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len))) | | ------------------ | | | | 849| 1.85M|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | | | ------------------ | | | | | | 828| 1.85M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 1.85M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 1.85M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 27436| 1.85M| } 27437| 1.85M| } 27438| 2.67M| p->bufcount = 0; 27439| 2.67M| popstate(p, ret); 27440| 2.67M| return 0; 27441| 2.67M|} janet.c:check_str_const: 27378| 5.57M|static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) { 27379| 5.57M| int32_t index; 27380| 5.60M| for (index = 0; index < len; index++) { ------------------ | Branch (27380:21): [True: 5.57M, False: 33.5k] ------------------ 27381| 5.57M| uint8_t c = str[index]; 27382| 5.57M| uint8_t k = ((const uint8_t *)cstr)[index]; 27383| 5.57M| if (c < k) return -1; ------------------ | Branch (27383:13): [True: 5.12M, False: 453k] ------------------ 27384| 453k| if (c > k) return 1; ------------------ | Branch (27384:13): [True: 417k, False: 35.7k] ------------------ 27385| 35.7k| if (k == '\0') break; ------------------ | Branch (27385:13): [True: 0, False: 35.7k] ------------------ 27386| 35.7k| } 27387| 33.5k| return (cstr[index] == '\0') ? 0 : -1; ------------------ | Branch (27387:12): [True: 501, False: 33.0k] ------------------ 27388| 5.57M|} janet.c:number_to_string_b: 30448| 19.9k|static void number_to_string_b(JanetBuffer *buffer, double x) { 30449| 19.9k| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |30442| 19.9k|#define BUFSIZE 64 ------------------ 30450| 19.9k| const char *fmt = (x == floor(x) && ------------------ | Branch (30450:24): [True: 19.8k, False: 63] ------------------ 30451| 19.8k| x <= JANET_INTMAX_DOUBLE && ------------------ | | 165| 39.7k|#define JANET_INTMAX_DOUBLE 9007199254740992.0 ------------------ | Branch (30451:24): [True: 19.8k, False: 48] ------------------ 30452| 19.8k| x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g"); ------------------ | | 166| 19.8k|#define JANET_INTMIN_DOUBLE (-9007199254740992.0) ------------------ | Branch (30452:24): [True: 19.8k, False: 0] ------------------ 30453| 19.9k| int count; 30454| 19.9k| if (x == 0.0) { ------------------ | Branch (30454:9): [True: 3.98k, False: 15.9k] ------------------ 30455| | /* Prevent printing of '-0' */ 30456| 3.98k| count = 1; 30457| 3.98k| buffer->data[buffer->count] = '0'; 30458| 15.9k| } else { 30459| 15.9k| count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x); ------------------ | |30442| 15.9k|#define BUFSIZE 64 ------------------ 30460| 15.9k| } 30461| 19.9k| buffer->count += count; 30462| 19.9k|} janet.c:string_description_b: 30508| 124|static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) { 30509| 124| janet_buffer_extra(buffer, BUFSIZE); ------------------ | |30442| 124|#define BUFSIZE 64 ------------------ 30510| 124| uint8_t *c = buffer->data + buffer->count; 30511| 124| int32_t i; 30512| 124| union { 30513| 124| uint8_t bytes[sizeof(void *)]; 30514| 124| void *p; 30515| 124| } pbuf; 30516| | 30517| 124| pbuf.p = pointer; 30518| 124| *c++ = '<'; 30519| | /* Maximum of 32 bytes for abstract type name */ 30520| 744| for (i = 0; i < 32 && title[i]; ++i) ------------------ | Branch (30520:17): [True: 744, False: 0] | Branch (30520:27): [True: 620, False: 124] ------------------ 30521| 620| *c++ = ((uint8_t *)title) [i]; 30522| 124| *c++ = ' '; 30523| 124| *c++ = '0'; 30524| 124| *c++ = 'x'; 30525| 124|#if defined(JANET_NANBOX_64) 30526| 124|#define POINTSIZE 6 30527| |#else 30528| |#define POINTSIZE (sizeof(void *)) 30529| |#endif 30530| 868| for (i = POINTSIZE; i > 0; --i) { ------------------ | |30526| 124|#define POINTSIZE 6 ------------------ | Branch (30530:25): [True: 744, False: 124] ------------------ 30531| 744| uint8_t byte = pbuf.bytes[i - 1]; 30532| 744| *c++ = HEX(byte >> 4); ------------------ | |30504| 744|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 30533| 744| *c++ = HEX(byte & 0xF); ------------------ | |30504| 744|#define HEX(i) (((uint8_t *) janet_base64)[(i)]) ------------------ 30534| 744| } 30535| 124| *c++ = '>'; 30536| 124| buffer->count = (int32_t)(c - buffer->data); 30537| 124|#undef POINTSIZE 30538| 124|} janet.c:janet_escape_string_b: 30610| 119k|static void janet_escape_string_b(JanetBuffer *buffer, const uint8_t *str) { 30611| | janet_escape_string_impl(buffer, str, janet_string_length(str)); ------------------ | | 1813| 119k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 119k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30612| 119k|} janet.c:janet_escape_string_impl: 30540| 119k|static int janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) { 30541| 119k| janet_buffer_push_u8(buffer, '"'); 30542| 119k| int align = 1; 30543| 897k| for (int32_t i = 0; i < len; ++i) { ------------------ | Branch (30543:25): [True: 777k, False: 119k] ------------------ 30544| 777k| uint8_t c = str[i]; 30545| 777k| switch (c) { 30546| 507| case '"': ------------------ | Branch (30546:13): [True: 507, False: 777k] ------------------ 30547| 507| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\"", 2); 30548| 507| align += 2; 30549| 507| break; 30550| 447| case '\n': ------------------ | Branch (30550:13): [True: 447, False: 777k] ------------------ 30551| 447| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\n", 2); 30552| 447| align += 2; 30553| 447| break; 30554| 7| case '\r': ------------------ | Branch (30554:13): [True: 7, False: 777k] ------------------ 30555| 7| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\r", 2); 30556| 7| align += 2; 30557| 7| break; 30558| 53.2k| case '\0': ------------------ | Branch (30558:13): [True: 53.2k, False: 724k] ------------------ 30559| 53.2k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\0", 2); 30560| 53.2k| align += 2; 30561| 53.2k| break; 30562| 4| case '\f': ------------------ | Branch (30562:13): [True: 4, False: 777k] ------------------ 30563| 4| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\f", 2); 30564| 4| align += 2; 30565| 4| break; 30566| 1.04k| case '\v': ------------------ | Branch (30566:13): [True: 1.04k, False: 776k] ------------------ 30567| 1.04k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\v", 2); 30568| 1.04k| align += 2; 30569| 1.04k| break; 30570| 2| case '\a': ------------------ | Branch (30570:13): [True: 2, False: 777k] ------------------ 30571| 2| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\a", 2); 30572| 2| align += 2; 30573| 2| break; 30574| 846| case '\b': ------------------ | Branch (30574:13): [True: 846, False: 776k] ------------------ 30575| 846| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\b", 2); 30576| 846| align += 2; 30577| 846| break; 30578| 0| case 27: ------------------ | Branch (30578:13): [True: 0, False: 777k] ------------------ 30579| 0| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\e", 2); 30580| 0| align += 2; 30581| 0| break; 30582| 0| case '\\': ------------------ | Branch (30582:13): [True: 0, False: 777k] ------------------ 30583| 0| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\\\", 2); 30584| 0| align += 2; 30585| 0| break; 30586| 9.14k| case '\t': ------------------ | Branch (30586:13): [True: 9.14k, False: 768k] ------------------ 30587| 9.14k| janet_buffer_push_bytes(buffer, (const uint8_t *)"\\t", 2); 30588| 9.14k| align += 2; 30589| 9.14k| break; 30590| 712k| default: ------------------ | Branch (30590:13): [True: 712k, False: 65.2k] ------------------ 30591| 712k| if (c < 32 || c > 126) { ------------------ | Branch (30591:21): [True: 481, False: 712k] | Branch (30591:31): [True: 155k, False: 556k] ------------------ 30592| 155k| uint8_t buf[4]; 30593| 155k| buf[0] = '\\'; 30594| 155k| buf[1] = 'x'; 30595| 155k| buf[2] = janet_base64[(c >> 4) & 0xF]; 30596| 155k| buf[3] = janet_base64[c & 0xF]; 30597| 155k| janet_buffer_push_bytes(buffer, buf, 4); 30598| 155k| align += 4; 30599| 556k| } else { 30600| 556k| janet_buffer_push_u8(buffer, c); 30601| 556k| align++; 30602| 556k| } 30603| 712k| break; 30604| 777k| } 30605| 777k| } 30606| 119k| janet_buffer_push_u8(buffer, '"'); 30607| 119k| return align + 1; 30608| 119k|} janet.c:janet_escape_buffer_b: 30614| 49|static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) { 30615| 49| if (bx == buffer) { ------------------ | Branch (30615:9): [True: 0, False: 49] ------------------ 30616| | /* Ensures buffer won't resize while escaping */ 30617| 0| int64_t new_size = 6 * (int64_t) bx->count + 3; 30618| 0| if (new_size > INT32_MAX) janet_panic("buffer overflow"); ------------------ | Branch (30618:13): [True: 0, False: 0] ------------------ 30619| 0| janet_buffer_ensure(bx, (int32_t) new_size, 1); 30620| 0| } 30621| 49| janet_buffer_push_u8(buffer, '@'); 30622| 49| janet_escape_string_impl(buffer, bx->data, bx->count); 30623| 49|} janet.c:janet_pretty_: 31237| 10.0k| int flags, Janet x, int32_t startlen, int32_t lookback_barrier) { 31238| 10.0k| struct pretty S; 31239| 10.0k| if (NULL == buffer) { ------------------ | Branch (31239:9): [True: 0, False: 10.0k] ------------------ 31240| 0| buffer = janet_buffer(0); 31241| 0| } 31242| 10.0k| S.buffer = buffer; 31243| 10.0k| S.depth = depth; 31244| 10.0k| S.width = width; 31245| 10.0k| S.align = 0; 31246| 10.0k| S.flags = flags; 31247| 10.0k| S.bufstartlen = startlen; 31248| 10.0k| S.lookback_barrier = lookback_barrier; 31249| 10.0k| S.keysort_capacity = 0; 31250| | S.keysort_buffer = NULL; 31251| 10.0k| S.keysort_start = 0; 31252| 10.0k| janet_table_init(&S.seen, 10); 31253| 10.0k| janet_pretty_one(&S, x); 31254| 10.0k| backtrack_newlines(&S); 31255| 10.0k| janet_table_deinit(&S.seen); 31256| 10.0k| return S.buffer; 31257| 10.0k|} janet.c:janet_pretty_one: 31004| 206k|static void janet_pretty_one(struct pretty *S, Janet x) { 31005| | /* Add to seen */ 31006| 206k| switch (janet_type(x)) { ------------------ | | 795| 206k| (isnan((x).number) \ | | 796| 206k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 206k| : JANET_NUMBER) ------------------ | Branch (31006:13): [True: 197k, False: 9.20k] ------------------ 31007| 472| case JANET_NIL: ------------------ | Branch (31007:9): [True: 472, False: 205k] ------------------ 31008| 9.67k| case JANET_NUMBER: ------------------ | Branch (31008:9): [True: 9.20k, False: 197k] ------------------ 31009| 116k| case JANET_SYMBOL: ------------------ | Branch (31009:9): [True: 106k, False: 99.5k] ------------------ 31010| 116k| case JANET_BOOLEAN: ------------------ | Branch (31010:9): [True: 0, False: 206k] ------------------ 31011| 116k| break; 31012| 89.8k| default: { ------------------ | Branch (31012:9): [True: 89.8k, False: 116k] ------------------ 31013| 89.8k| Janet seenid = janet_table_get(&S->seen, x); 31014| 89.8k| if (janet_checktype(seenid, JANET_NUMBER)) { ------------------ | | 806| 89.8k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 89.8k] | | | Branch (806:6): [True: 89.8k, Folded] | | ------------------ | | 807| 89.8k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 89.8k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 89.8k] | | | | | Branch (803:28): [True: 0, False: 89.8k] | | | | ------------------ | | ------------------ | | 808| 89.8k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31015| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31015:21): [True: 0, False: 0] ------------------ 31016| 0| janet_buffer_push_cstring(S->buffer, janet_cycle_color); 31017| 0| } 31018| 0| janet_buffer_push_cstring(S->buffer, "align += 8 + integer_to_string_b(S->buffer, janet_unwrap_integer(seenid)); ------------------ | | 966| 0|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 31020| 0| janet_buffer_push_u8(S->buffer, '>'); 31021| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31021:21): [True: 0, False: 0] ------------------ 31022| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31023| 0| } 31024| 0| return; 31025| 89.8k| } else { 31026| 89.8k| janet_table_put(&S->seen, x, janet_wrap_integer(S->seen.count)); ------------------ | | 967| 89.8k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 89.8k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 31027| 89.8k| break; 31028| 89.8k| } 31029| 89.8k| } 31030| 206k| } 31031| | 31032| 206k| switch (janet_type(x)) { ------------------ | | 795| 206k| (isnan((x).number) \ | | 796| 206k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 206k| : JANET_NUMBER) ------------------ | Branch (31032:13): [True: 197k, False: 9.20k] ------------------ 31033| 125k| default: { ------------------ | Branch (31033:9): [True: 125k, False: 80.7k] ------------------ 31034| 125k| const char *color = janet_pretty_colors[janet_type(x)]; ------------------ | | 795| 125k| (isnan((x).number) \ | | 796| 125k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 125k| : JANET_NUMBER) ------------------ | Branch (31034:53): [True: 116k, False: 9.20k] ------------------ 31035| 125k| if (color && (S->flags & JANET_PRETTY_COLOR)) { ------------------ | | 1967| 125k|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31035:17): [True: 125k, False: 0] | Branch (31035:26): [True: 0, False: 125k] ------------------ 31036| 0| janet_buffer_push_cstring(S->buffer, color); 31037| 0| } 31038| 125k| if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) { ------------------ | | 806| 251k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 125k] | | | Branch (806:6): [Folded, False: 125k] | | ------------------ | | 807| 251k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 251k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 125k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 125k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 125k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 125k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(x, JANET_BUFFER) && janet_unwrap_buffer(x) == S->buffer) { ------------------ | | 862| 0|#define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x)) ------------------ | Branch (31038:53): [True: 0, False: 0] ------------------ 31039| 0| int64_t new_size = (int64_t) S->buffer->count + S->bufstartlen * 4 + 3; 31040| 0| if (new_size > INT32_MAX) janet_panic("buffer overflow"); ------------------ | Branch (31040:21): [True: 0, False: 0] ------------------ 31041| 0| janet_buffer_ensure(S->buffer, (int32_t) new_size, 1); 31042| 0| janet_buffer_push_u8(S->buffer, '@'); 31043| | /* Use start len to print to self better */ 31044| 0| S->align += 1 + janet_escape_string_impl(S->buffer, S->buffer->data, S->bufstartlen); 31045| 125k| } else { 31046| 125k| S->align -= S->buffer->count; 31047| 125k| janet_description_b(S->buffer, x); 31048| 125k| S->align += S->buffer->count; 31049| 125k| } 31050| 125k| if (color && (S->flags & JANET_PRETTY_COLOR)) { ------------------ | | 1967| 125k|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31050:17): [True: 125k, False: 0] | Branch (31050:26): [True: 0, False: 125k] ------------------ 31051| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31052| 0| } 31053| 125k| break; 31054| 125k| } 31055| 0| case JANET_ARRAY: ------------------ | Branch (31055:9): [True: 0, False: 206k] ------------------ 31056| 80.3k| case JANET_TUPLE: { ------------------ | Branch (31056:9): [True: 80.3k, False: 126k] ------------------ 31057| 80.3k| int32_t i = 0, len = 0; 31058| 80.3k| const Janet *arr = NULL; 31059| 80.3k| int isarray = janet_checktype(x, JANET_ARRAY); ------------------ | | 806| 80.3k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 80.3k] | | ------------------ | | 807| 80.3k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 80.3k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 80.3k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 80.3k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 80.3k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 80.3k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31060| 80.3k| janet_indexed_view(x, &arr, &len); 31061| 80.3k| int hasbrackets = !isarray && (janet_tuple_flag(arr) & JANET_TUPLE_FLAG_BRACKETCTOR); ------------------ | | 1806| 80.3k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 80.3k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ int hasbrackets = !isarray && (janet_tuple_flag(arr) & JANET_TUPLE_FLAG_BRACKETCTOR); ------------------ | | 1798| 80.3k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (31061:31): [True: 80.3k, False: 0] | Branch (31061:43): [True: 474, False: 79.8k] ------------------ 31062| 80.3k| const char *startstr = isarray ? "@[" : hasbrackets ? "[" : "("; ------------------ | Branch (31062:36): [True: 0, False: 80.3k] | Branch (31062:53): [True: 474, False: 79.8k] ------------------ 31063| 80.3k| const char endchar = isarray ? ']' : hasbrackets ? ']' : ')'; ------------------ | Branch (31063:34): [True: 0, False: 80.3k] | Branch (31063:50): [True: 474, False: 79.8k] ------------------ 31064| 80.3k| janet_buffer_push_cstring(S->buffer, startstr); 31065| 80.3k| S->align += (int32_t) strlen(startstr); 31066| 80.3k| const int align = S->leaf_align = S->align; 31067| 80.3k| S->depth--; 31068| 80.3k| if (S->depth == 0) { ------------------ | Branch (31068:17): [True: 35, False: 80.3k] ------------------ 31069| 35| janet_buffer_push_cstring(S->buffer, "..."); 31070| 35| S->align += 3; 31071| 80.3k| } else { 31072| 80.3k| if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) { ------------------ | |31001| 160k|#define JANET_PRETTY_ARRAY_LIMIT 160 ------------------ if (len > JANET_PRETTY_ARRAY_LIMIT && !(S->flags & JANET_PRETTY_NOTRUNC)) { ------------------ | | 1969| 2|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31072:21): [True: 2, False: 80.3k] | Branch (31072:55): [True: 1, False: 1] ------------------ 31073| 4| for (i = 0; i < 3; i++) { ------------------ | Branch (31073:33): [True: 3, False: 1] ------------------ 31074| 3| if (i) print_newline(S, align); ------------------ | Branch (31074:29): [True: 2, False: 1] ------------------ 31075| 3| janet_pretty_one(S, arr[i]); 31076| 3| } 31077| 1| print_newline(S, align); 31078| 1| janet_buffer_push_cstring(S->buffer, "..."); 31079| 1| S->align += 3; 31080| 4| for (i = len - 3; i < len; i++) { ------------------ | Branch (31080:39): [True: 3, False: 1] ------------------ 31081| 3| print_newline(S, align); 31082| 3| janet_pretty_one(S, arr[i]); 31083| 3| } 31084| 80.3k| } else { 31085| 275k| for (i = 0; i < len; i++) { ------------------ | Branch (31085:33): [True: 195k, False: 80.3k] ------------------ 31086| 195k| if (i) print_newline(S, align); ------------------ | Branch (31086:29): [True: 115k, False: 79.8k] ------------------ 31087| 195k| janet_pretty_one(S, arr[i]); 31088| 195k| } 31089| 80.3k| } 31090| 80.3k| } 31091| 80.3k| S->depth++; 31092| 80.3k| janet_buffer_push_u8(S->buffer, endchar); 31093| 80.3k| S->align++; 31094| 80.3k| break; 31095| 0| } 31096| 51| case JANET_STRUCT: ------------------ | Branch (31096:9): [True: 51, False: 206k] ------------------ 31097| 446| case JANET_TABLE: { ------------------ | Branch (31097:9): [True: 395, False: 205k] ------------------ 31098| 446| int istable = janet_checktype(x, JANET_TABLE); ------------------ | | 806| 446| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 446] | | ------------------ | | 807| 446| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 446| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 446| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 446|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 446|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 446|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31099| | 31100| | /* For object-like tables, print class name */ 31101| 446| if (istable) { ------------------ | Branch (31101:17): [True: 395, False: 51] ------------------ 31102| 395| JanetTable *t = janet_unwrap_table(x); ------------------ | | 861| 395|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 31103| 395| JanetTable *proto = t->proto; 31104| 395| S->align++; 31105| 395| janet_buffer_push_cstring(S->buffer, "@"); 31106| 395| if (NULL != proto) { ------------------ | Branch (31106:21): [True: 0, False: 395] ------------------ 31107| 0| Janet name = janet_table_get(proto, janet_ckeywordv("_name")); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31108| 0| const uint8_t *n; 31109| 0| int32_t len; 31110| 0| if (janet_bytes_view(name, &n, &len)) { ------------------ | Branch (31110:25): [True: 0, False: 0] ------------------ 31111| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31111:29): [True: 0, False: 0] ------------------ 31112| 0| janet_buffer_push_cstring(S->buffer, janet_class_color); 31113| 0| } 31114| 0| janet_buffer_push_bytes(S->buffer, n, len); 31115| 0| S->align += len; 31116| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31116:29): [True: 0, False: 0] ------------------ 31117| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31118| 0| } 31119| 0| } 31120| 0| } 31121| 395| } else { 31122| 51| JanetStruct st = janet_unwrap_struct(x); ------------------ | | 857| 51|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 31123| 51| JanetStruct proto = janet_struct_proto(st); ------------------ | | 1851| 51|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 51|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ 31124| 51| if (NULL != proto) { ------------------ | Branch (31124:21): [True: 0, False: 51] ------------------ 31125| 0| Janet name = janet_struct_get(proto, janet_ckeywordv("_name")); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31126| 0| const uint8_t *n; 31127| 0| int32_t len; 31128| 0| if (janet_bytes_view(name, &n, &len)) { ------------------ | Branch (31128:25): [True: 0, False: 0] ------------------ 31129| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31129:29): [True: 0, False: 0] ------------------ 31130| 0| janet_buffer_push_cstring(S->buffer, janet_class_color); 31131| 0| } 31132| 0| janet_buffer_push_bytes(S->buffer, n, len); 31133| 0| S->align += len; 31134| 0| if (S->flags & JANET_PRETTY_COLOR) { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (31134:29): [True: 0, False: 0] ------------------ 31135| 0| janet_buffer_push_cstring(S->buffer, "\x1B[0m"); 31136| 0| } 31137| 0| } 31138| 0| } 31139| 51| } 31140| 446| janet_buffer_push_u8(S->buffer, '{'); 31141| 446| const int align = S->leaf_align = ++S->align; 31142| | 31143| 446| S->depth--; 31144| 446| if (S->depth == 0) { ------------------ | Branch (31144:17): [True: 10, False: 436] ------------------ 31145| 10| janet_buffer_push_cstring(S->buffer, "..."); 31146| 10| S->align += 3; 31147| 436| } else { 31148| 436| int32_t len = 0, cap = 0; 31149| 436| const JanetKV *kvs = NULL; 31150| 436| janet_dictionary_view(x, &kvs, &len, &cap); 31151| 436| int32_t ks_start = S->keysort_start; 31152| 436| int truncated = 0; 31153| | 31154| | /* Shortcut for huge dictionaries, don't bother sorting keys */ 31155| 436| if (len > JANET_PRETTY_DICT_KEYSORT_LIMIT) { ------------------ | |31000| 436|#define JANET_PRETTY_DICT_KEYSORT_LIMIT 2000 ------------------ | Branch (31155:21): [True: 0, False: 436] ------------------ 31156| 0| if (!(S->flags & JANET_PRETTY_NOTRUNC)) { ------------------ | | 1969| 0|#define JANET_PRETTY_NOTRUNC 4 ------------------ | Branch (31156:25): [True: 0, False: 0] ------------------ 31157| 0| len = JANET_PRETTY_DICT_LIMIT; ------------------ | |30999| 0|#define JANET_PRETTY_DICT_LIMIT 30 ------------------ 31158| 0| truncated = 1; 31159| 0| } 31160| 0| int32_t j = 0; 31161| 0| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (31161:41): [True: 0, False: 0] ------------------ 31162| 0| while (janet_checktype(kvs[j].key, JANET_NIL)) j++; ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 31163| 0| if (i) print_newline(S, align); ------------------ | Branch (31163:29): [True: 0, False: 0] ------------------ 31164| 0| janet_pretty_one(S, kvs[j].key); 31165| 0| janet_buffer_push_u8(S->buffer, ' '); 31166| 0| S->align++; 31167| 0| janet_pretty_one(S, kvs[j].value); 31168| 0| j++; 31169| 0| } 31170| 0| if (truncated) { ------------------ | Branch (31170:25): [True: 0, False: 0] ------------------ 31171| 0| print_newline(S, align); 31172| 0| janet_buffer_push_cstring(S->buffer, "..."); 31173| 0| S->align += 3; 31174| 0| } 31175| 436| } else { 31176| | /* Sorted keys dictionaries */ 31177| | 31178| | /* Ensure buffer is large enough to sort keys. */ 31179| 436| int64_t mincap = (int64_t) len + (int64_t) ks_start; 31180| 436| if (mincap > INT32_MAX) { ------------------ | Branch (31180:25): [True: 0, False: 436] ------------------ 31181| 0| truncated = 1; 31182| 0| len = 0; 31183| 0| mincap = ks_start; 31184| 0| } 31185| | 31186| 436| if (S->keysort_capacity < mincap) { ------------------ | Branch (31186:25): [True: 9, False: 427] ------------------ 31187| 9| if (mincap >= INT32_MAX / 2) { ------------------ | Branch (31187:29): [True: 0, False: 9] ------------------ 31188| 0| S->keysort_capacity = INT32_MAX; 31189| 9| } else { 31190| 9| S->keysort_capacity = (int32_t)(mincap * 2); 31191| 9| } 31192| 9| S->keysort_buffer = janet_srealloc(S->keysort_buffer, sizeof(int32_t) * S->keysort_capacity); 31193| 9| if (NULL == S->keysort_buffer) { ------------------ | Branch (31193:29): [True: 0, False: 9] ------------------ 31194| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 31195| 0| } 31196| 9| } 31197| | 31198| 436| janet_sorted_keys(kvs, cap, S->keysort_buffer == NULL ? NULL : S->keysort_buffer + ks_start); ------------------ | Branch (31198:49): [True: 43, False: 393] ------------------ 31199| 436| S->keysort_start += len; 31200| 436| if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) { ------------------ | | 1969| 436|#define JANET_PRETTY_NOTRUNC 4 ------------------ if (!(S->flags & JANET_PRETTY_NOTRUNC) && (len > JANET_PRETTY_DICT_LIMIT)) { ------------------ | |30999| 429|#define JANET_PRETTY_DICT_LIMIT 30 ------------------ | Branch (31200:25): [True: 429, False: 7] | Branch (31200:63): [True: 0, False: 429] ------------------ 31201| 0| len = JANET_PRETTY_DICT_LIMIT; ------------------ | |30999| 0|#define JANET_PRETTY_DICT_LIMIT 30 ------------------ 31202| 0| truncated = 1; 31203| 0| } 31204| | 31205| 883| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (31205:41): [True: 447, False: 436] ------------------ 31206| 447| if (i) print_newline(S, align); ------------------ | Branch (31206:29): [True: 54, False: 393] ------------------ 31207| 447| int32_t j = S->keysort_buffer[i + ks_start]; 31208| 447| janet_pretty_one(S, kvs[j].key); 31209| 447| janet_buffer_push_u8(S->buffer, ' '); 31210| 447| S->align++; 31211| 447| janet_pretty_one(S, kvs[j].value); 31212| 447| } 31213| | 31214| 436| if (truncated) { ------------------ | Branch (31214:25): [True: 0, False: 436] ------------------ 31215| 0| print_newline(S, align); 31216| 0| janet_buffer_push_cstring(S->buffer, "..."); 31217| 0| S->align += 3; 31218| 0| } 31219| | 31220| 436| } 31221| 436| S->keysort_start = ks_start; 31222| 436| } 31223| 446| S->depth++; 31224| 446| janet_buffer_push_u8(S->buffer, '}'); 31225| 446| S->align++; 31226| 446| break; 31227| 446| } 31228| 206k| } 31229| | /* Remove from seen */ 31230| 206k| janet_table_remove(&S->seen, x); 31231| 206k| return; 31232| 206k|} janet.c:print_newline: 30963| 115k|static void print_newline(struct pretty *S, int align) { 30964| 115k| int i; 30965| 115k| if (S->flags & JANET_PRETTY_ONELINE) { ------------------ | | 1968| 115k|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (30965:9): [True: 115k, False: 0] ------------------ 30966| 115k| janet_buffer_push_u8(S->buffer, ' '); 30967| 115k| return; 30968| 115k| } 30969| 0| backtrack_newlines(S); 30970| 0| janet_buffer_push_u8(S->buffer, '\n'); 30971| 0| S->leaf_align = S->align = align; 30972| 0| for (i = 0; i < S->align; i++) { ------------------ | Branch (30972:17): [True: 0, False: 0] ------------------ 30973| 0| janet_buffer_push_u8(S->buffer, ' '); 30974| 0| } 30975| 0|} janet.c:backtrack_newlines: 30903| 10.0k|static void backtrack_newlines(const struct pretty *S) { 30904| 10.0k| if (S->flags & JANET_PRETTY_ONELINE || S->buffer->count <= 0) ------------------ | | 1968| 20.1k|#define JANET_PRETTY_ONELINE 2 ------------------ | Branch (30904:9): [True: 10.0k, False: 0] | Branch (30904:44): [True: 0, False: 0] ------------------ 30905| 10.0k| return; 30906| 0| switch (S->buffer->data[S->buffer->count - 1]) { 30907| 0| case ')': ------------------ | Branch (30907:9): [True: 0, False: 0] ------------------ 30908| 0| case '}': ------------------ | Branch (30908:9): [True: 0, False: 0] ------------------ 30909| 0| case ']': ------------------ | Branch (30909:9): [True: 0, False: 0] ------------------ 30910| 0| break; 30911| 0| default: ------------------ | Branch (30911:9): [True: 0, False: 0] ------------------ 30912| 0| return; 30913| 0| } 30914| 0| int32_t removed = 0; 30915| 0| int32_t old_count = S->buffer->count; 30916| 0| int32_t offset = old_count; 30917| 0| int32_t b0 = S->lookback_barrier; 30918| 0| int32_t columns = S->width; 30919| 0| int32_t align = 0; 30920| 0| while (--offset >= b0) { ------------------ | Branch (30920:12): [True: 0, False: 0] ------------------ 30921| 0| const char *s = (const char *)S->buffer->data + offset; 30922| 0| if (*s == '\n') { ------------------ | Branch (30922:13): [True: 0, False: 0] ------------------ 30923| 0| if (align < S->leaf_align) { ------------------ | Branch (30923:17): [True: 0, False: 0] ------------------ 30924| 0| break; 30925| 0| } 30926| 0| columns += align; 30927| 0| removed += align; 30928| 0| align = 0; 30929| 0| } else if (*s == ' ') { ------------------ | Branch (30929:20): [True: 0, False: 0] ------------------ 30930| 0| align++; 30931| 0| } else { 30932| 0| align = 0; 30933| | /* Don't count color sequences: \x1B(0|3\d)m */ 30934| 0| if (S->flags & JANET_PRETTY_COLOR && *s == 'm') { ------------------ | | 1967| 0|#define JANET_PRETTY_COLOR 1 ------------------ | Branch (30934:17): [True: 0, False: 0] | Branch (30934:50): [True: 0, False: 0] ------------------ 30935| 0| if (offset >= (3 + b0) && strncmp("\x1B[0m", s - 3, 4) == 0) { ------------------ | Branch (30935:21): [True: 0, False: 0] | Branch (30935:43): [True: 0, False: 0] ------------------ 30936| 0| offset -= 3; 30937| 0| columns++; 30938| 0| } else if (offset >= (4 + b0) && strncmp("\x1B[3", s - 4, 3) == 0) { ------------------ | Branch (30938:28): [True: 0, False: 0] | Branch (30938:50): [True: 0, False: 0] ------------------ 30939| 0| offset -= 4; 30940| 0| columns++; 30941| 0| } 30942| 0| } 30943| 0| } 30944| 0| if (--columns <= 0) { ------------------ | Branch (30944:13): [True: 0, False: 0] ------------------ 30945| 0| return; 30946| 0| } 30947| 0| } 30948| 0| offset++; /* Don't mess with the last newline we found */ 30949| 0| janet_assert(offset >= b0, "bad buffer index"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 30950| 0| S->buffer->count -= removed; 30951| 0| for (int32_t i = offset; i < S->buffer->count; i++) { ------------------ | Branch (30951:30): [True: 0, False: 0] ------------------ 30952| 0| if (S->buffer->data[offset] == '\n') { ------------------ | Branch (30952:13): [True: 0, False: 0] ------------------ 30953| 0| S->buffer->data[i] = ' '; 30954| 0| while (S->buffer->data[++offset] == ' ') { ------------------ | Branch (30954:20): [True: 0, False: 0] ------------------ 30955| 0| janet_assert(offset < old_count, "bad replacement of newline"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 0] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 30956| 0| } 30957| 0| } else { 30958| 0| S->buffer->data[i] = S->buffer->data[offset++]; 30959| 0| } 30960| 0| } 30961| 0|} janet.c:janet_jdn_: 31266| 44.1k|static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t startlen, int32_t lookback_barrier) { 31267| 44.1k| struct pretty S; 31268| 44.1k| if (NULL == buffer) { ------------------ | Branch (31268:9): [True: 0, False: 44.1k] ------------------ 31269| 0| buffer = janet_buffer(0); 31270| 0| } 31271| 44.1k| S.buffer = buffer; 31272| 44.1k| S.depth = depth; 31273| 44.1k| S.align = 0; 31274| 44.1k| S.flags = 0; 31275| 44.1k| S.bufstartlen = startlen; 31276| 44.1k| S.lookback_barrier = lookback_barrier; 31277| 44.1k| S.keysort_capacity = 0; 31278| 44.1k| S.keysort_buffer = NULL; 31279| 44.1k| S.keysort_start = 0; 31280| 44.1k| janet_table_init(&S.seen, 10); 31281| 44.1k| int res = print_jdn_one(&S, x, depth); 31282| 44.1k| janet_table_deinit(&S.seen); 31283| 44.1k| if (res) { ------------------ | Branch (31283:9): [True: 0, False: 44.1k] ------------------ 31284| 0| janet_panic("could not print to jdn format"); 31285| 0| } 31286| 44.1k| return S.buffer; 31287| 44.1k|} janet.c:print_jdn_one: 30794| 1.18M|static int print_jdn_one(struct pretty *S, Janet x, int depth) { 30795| 1.18M| if (depth == 0) return 1; ------------------ | Branch (30795:9): [True: 0, False: 1.18M] ------------------ 30796| 1.18M| switch (janet_type(x)) { ------------------ | | 795| 1.18M| (isnan((x).number) \ | | 796| 1.18M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 1.18M| : JANET_NUMBER) ------------------ | Branch (30796:13): [True: 1.13M, False: 49.0k] ------------------ 30797| 0| case JANET_NIL: ------------------ | Branch (30797:9): [True: 0, False: 1.18M] ------------------ 30798| 20| case JANET_BOOLEAN: ------------------ | Branch (30798:9): [True: 20, False: 1.18M] ------------------ 30799| 68| case JANET_BUFFER: ------------------ | Branch (30799:9): [True: 48, False: 1.18M] ------------------ 30800| 44.2k| case JANET_STRING: ------------------ | Branch (30800:9): [True: 44.2k, False: 1.14M] ------------------ 30801| 44.2k| janet_description_b(S->buffer, x); 30802| 44.2k| break; 30803| 49.0k| case JANET_NUMBER: ------------------ | Branch (30803:9): [True: 49.0k, False: 1.13M] ------------------ 30804| 49.0k| janet_buffer_extra(S->buffer, BUFSIZE); ------------------ | |30442| 49.0k|#define BUFSIZE 64 ------------------ 30805| 49.0k| double num = janet_unwrap_number(x); ------------------ | | 839| 49.0k|#define janet_unwrap_number(x) ((x).number) ------------------ 30806| 49.0k| if (isnan(num)) return 1; ------------------ | Branch (30806:17): [True: 0, False: 49.0k] ------------------ 30807| 49.0k| if (isinf(num)) return 1; ------------------ | Branch (30807:17): [True: 0, False: 49.0k] ------------------ 30808| 49.0k| janet_buffer_dtostr(S->buffer, num); 30809| 49.0k| break; 30810| 567k| case JANET_SYMBOL: ------------------ | Branch (30810:9): [True: 567k, False: 620k] ------------------ 30811| 568k| case JANET_KEYWORD: ------------------ | Branch (30811:9): [True: 295, False: 1.18M] ------------------ 30812| 568k| if (contains_bad_chars(janet_unwrap_keyword(x), janet_type(x) == JANET_SYMBOL)) return 1; ------------------ | | 865| 568k|#define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x)) ------------------ if (contains_bad_chars(janet_unwrap_keyword(x), janet_type(x) == JANET_SYMBOL)) return 1; ------------------ | | 795| 568k| (isnan((x).number) \ | | 796| 568k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 568k| : JANET_NUMBER) ------------------ | Branch (30812:17): [True: 0, False: 568k] | Branch (30812:61): [True: 568k, False: 0] ------------------ 30813| 568k| janet_description_b(S->buffer, x); 30814| 568k| break; 30815| 526k| case JANET_TUPLE: { ------------------ | Branch (30815:9): [True: 526k, False: 661k] ------------------ 30816| 526k| JanetTuple t = janet_unwrap_tuple(x); ------------------ | | 858| 526k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 30817| 526k| int isb = janet_tuple_flag(t) & JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1806| 526k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 526k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ int isb = janet_tuple_flag(t) & JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1798| 526k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ 30818| 526k| janet_buffer_push_u8(S->buffer, isb ? '[' : '('); ------------------ | Branch (30818:45): [True: 176, False: 526k] ------------------ 30819| 1.67M| for (int32_t i = 0; i < janet_tuple_length(t); i++) { ------------------ | | 1802| 1.67M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 1.67M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (30819:33): [True: 1.14M, False: 526k] ------------------ 30820| 1.14M| if (i) janet_buffer_push_u8(S->buffer, ' '); ------------------ | Branch (30820:21): [True: 617k, False: 526k] ------------------ 30821| 1.14M| if (print_jdn_one(S, t[i], depth - 1)) return 1; ------------------ | Branch (30821:21): [True: 0, False: 1.14M] ------------------ 30822| 1.14M| } 30823| 526k| janet_buffer_push_u8(S->buffer, isb ? ']' : ')'); ------------------ | Branch (30823:45): [True: 176, False: 526k] ------------------ 30824| 526k| } 30825| 0| break; 30826| 127| case JANET_ARRAY: { ------------------ | Branch (30826:9): [True: 127, False: 1.18M] ------------------ 30827| 127| janet_table_put(&S->seen, x, janet_wrap_true()); ------------------ | | 832| 127|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 127| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 127|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 127|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 30828| 127| JanetArray *a = janet_unwrap_array(x); ------------------ | | 860| 127|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 30829| 127| janet_buffer_push_cstring(S->buffer, "@["); 30830| 133| for (int32_t i = 0; i < a->count; i++) { ------------------ | Branch (30830:33): [True: 6, False: 127] ------------------ 30831| 6| if (i) janet_buffer_push_u8(S->buffer, ' '); ------------------ | Branch (30831:21): [True: 0, False: 6] ------------------ 30832| 6| if (print_jdn_one(S, a->data[i], depth - 1)) return 1; ------------------ | Branch (30832:21): [True: 0, False: 6] ------------------ 30833| 6| } 30834| 127| janet_buffer_push_u8(S->buffer, ']'); 30835| 127| } 30836| 0| break; 30837| 39| case JANET_TABLE: { ------------------ | Branch (30837:9): [True: 39, False: 1.18M] ------------------ 30838| 39| janet_table_put(&S->seen, x, janet_wrap_true()); ------------------ | | 832| 39|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 39| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 39|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 39|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 30839| 39| JanetTable *tab = janet_unwrap_table(x); ------------------ | | 861| 39|#define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x)) ------------------ 30840| 39| janet_buffer_push_cstring(S->buffer, "@{"); 30841| 39| int isFirst = 1; 30842| 431| for (int32_t i = 0; i < tab->capacity; i++) { ------------------ | Branch (30842:33): [True: 392, False: 39] ------------------ 30843| 392| const JanetKV *kv = tab->data + i; 30844| 392| if (janet_checktype(kv->key, JANET_NIL)) continue; ------------------ | | 806| 392| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 226, False: 166] | | | Branch (806:6): [Folded, False: 392] | | ------------------ | | 807| 392| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 392| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 392| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 392|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 392|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 392|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 30845| 166| if (!isFirst) janet_buffer_push_u8(S->buffer, ' '); ------------------ | Branch (30845:21): [True: 127, False: 39] ------------------ 30846| 166| isFirst = 0; 30847| 166| if (print_jdn_one(S, kv->key, depth - 1)) return 1; ------------------ | Branch (30847:21): [True: 0, False: 166] ------------------ 30848| 166| janet_buffer_push_u8(S->buffer, ' '); 30849| 166| if (print_jdn_one(S, kv->value, depth - 1)) return 1; ------------------ | Branch (30849:21): [True: 0, False: 166] ------------------ 30850| 166| } 30851| 39| janet_buffer_push_u8(S->buffer, '}'); 30852| 39| } 30853| 0| break; 30854| 23| case JANET_STRUCT: { ------------------ | Branch (30854:9): [True: 23, False: 1.18M] ------------------ 30855| 23| JanetStruct st = janet_unwrap_struct(x); ------------------ | | 857| 23|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 30856| 23| janet_buffer_push_u8(S->buffer, '{'); 30857| 23| int isFirst = 1; 30858| 207| for (int32_t i = 0; i < janet_struct_capacity(st); i++) { ------------------ | | 1849| 207|#define janet_struct_capacity(t) (janet_struct_head(t)->capacity) | | ------------------ | | | | 1846| 207|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (30858:33): [True: 184, False: 23] ------------------ 30859| 184| const JanetKV *kv = st + i; 30860| 184| if (janet_checktype(kv->key, JANET_NIL)) continue; ------------------ | | 806| 184| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 138, False: 46] | | | Branch (806:6): [Folded, False: 184] | | ------------------ | | 807| 184| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 184| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 184| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 184|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 184|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 184|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 30861| 46| if (!isFirst) janet_buffer_push_u8(S->buffer, ' '); ------------------ | Branch (30861:21): [True: 23, False: 23] ------------------ 30862| 46| isFirst = 0; 30863| 46| if (print_jdn_one(S, kv->key, depth - 1)) return 1; ------------------ | Branch (30863:21): [True: 0, False: 46] ------------------ 30864| 46| janet_buffer_push_u8(S->buffer, ' '); 30865| 46| if (print_jdn_one(S, kv->value, depth - 1)) return 1; ------------------ | Branch (30865:21): [True: 0, False: 46] ------------------ 30866| 46| } 30867| 23| janet_buffer_push_u8(S->buffer, '}'); 30868| 23| } 30869| 0| break; 30870| 0|#ifdef JANET_INT_TYPES 30871| 2| case JANET_ABSTRACT: { ------------------ | Branch (30871:9): [True: 2, False: 1.18M] ------------------ 30872| 2| void *abst = janet_unwrap_abstract(x); ------------------ | | 866| 2|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 30873| 2| if (janet_abstract_type(abst) == &janet_s64_type) { ------------------ | | 1899| 2|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 2|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ | Branch (30873:17): [True: 0, False: 2] ------------------ 30874| 0| janet_buffer_ensure(S->buffer, S->buffer->count + BUFSIZE, 2); ------------------ | |30442| 0|#define BUFSIZE 64 ------------------ 30875| 0| int64_t s64 = janet_unwrap_s64(x); 30876| 0| int count = snprintf((char *)S->buffer->data + S->buffer->count, 30877| 0| BUFSIZE, "%" PRId64 ":s", s64); ------------------ | |30442| 0|#define BUFSIZE 64 ------------------ 30878| 0| if (count < 0) { ------------------ | Branch (30878:21): [True: 0, False: 0] ------------------ 30879| 0| return 1; 30880| 0| } 30881| 0| S->buffer->count += count; 30882| 2| } else if (janet_abstract_type(abst) == &janet_u64_type) { ------------------ | | 1899| 2|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 2|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ | Branch (30882:24): [True: 2, False: 0] ------------------ 30883| 2| janet_buffer_ensure(S->buffer, S->buffer->count + BUFSIZE, 2); ------------------ | |30442| 2|#define BUFSIZE 64 ------------------ 30884| 2| uint64_t u64 = janet_unwrap_u64(x); 30885| 2| int count = snprintf((char *)S->buffer->data + S->buffer->count, 30886| 2| BUFSIZE, "%" PRIu64 ":u", u64); ------------------ | |30442| 2|#define BUFSIZE 64 ------------------ 30887| 2| if (count < 0) { ------------------ | Branch (30887:21): [True: 0, False: 2] ------------------ 30888| 0| return 1; 30889| 0| } 30890| 2| S->buffer->count += count; 30891| 2| } else { 30892| 0| return 1; 30893| 0| } 30894| 2| } 30895| 2| break; 30896| 2|#endif 30897| 2| default: ------------------ | Branch (30897:9): [True: 0, False: 1.18M] ------------------ 30898| 0| return 1; 30899| 1.18M| } 30900| 1.18M| return 0; 30901| 1.18M|} janet.c:contains_bad_chars: 30701| 568k|static int contains_bad_chars(const uint8_t *sym, int issym) { 30702| 568k| int32_t len = janet_string_length(sym); ------------------ | | 1813| 568k|#define janet_string_length(s) (janet_string_head(s)->length) | | ------------------ | | | | 1812| 568k|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 30703| 568k| if (len && issym && sym[0] >= '0' && sym[0] <= '9') return 1; ------------------ | Branch (30703:9): [True: 568k, False: 87] | Branch (30703:16): [True: 567k, False: 208] | Branch (30703:25): [True: 540k, False: 26.9k] | Branch (30703:42): [True: 0, False: 540k] ------------------ 30704| 568k| if (!janet_valid_utf8(sym, len)) return 1; ------------------ | Branch (30704:9): [True: 0, False: 568k] ------------------ 30705| 4.83M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (30705:25): [True: 4.26M, False: 568k] ------------------ 30706| 4.26M| if (!janet_is_symbol_char(sym[i])) return 1; ------------------ | Branch (30706:13): [True: 0, False: 4.26M] ------------------ 30707| 4.26M| } 30708| 568k| return 0; 30709| 568k|} janet.c:scanformat: 31356| 137k| char precision[3]) { 31357| 137k| const char *p = strfrmt; 31358| | 31359| | /* Parse strfrmt */ 31360| 137k| memset(width, '\0', 3); 31361| 137k| memset(precision, '\0', 3); 31362| 137k| while (*p != '\0' && strchr(FMT_FLAGS, *p) != NULL) ------------------ | |31322| 137k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (31362:12): [True: 137k, False: 0] | Branch (31362:26): [True: 0, False: 137k] ------------------ 31363| 0| p++; /* skip flags */ 31364| 137k| if ((size_t)(p - strfrmt) >= sizeof(FMT_FLAGS)) janet_panic("invalid format (repeated flags)"); ------------------ | |31322| 137k|#define FMT_FLAGS "-+ #0" ------------------ | Branch (31364:9): [True: 0, False: 137k] ------------------ 31365| 137k| if (isdigit((int)(*p))) ------------------ | Branch (31365:9): [True: 0, False: 137k] ------------------ 31366| 0| width[0] = *p++; /* skip width */ 31367| 137k| if (isdigit((int)(*p))) ------------------ | Branch (31367:9): [True: 0, False: 137k] ------------------ 31368| 0| width[1] = *p++; /* (2 digits at most) */ 31369| 137k| if (*p == '.') { ------------------ | Branch (31369:9): [True: 0, False: 137k] ------------------ 31370| 0| p++; 31371| 0| if (isdigit((int)(*p))) ------------------ | Branch (31371:13): [True: 0, False: 0] ------------------ 31372| 0| precision[0] = *p++; /* skip precision */ 31373| 0| if (isdigit((int)(*p))) ------------------ | Branch (31373:13): [True: 0, False: 0] ------------------ 31374| 0| precision[1] = *p++; /* (2 digits at most) */ 31375| 0| } 31376| 137k| if (isdigit((int)(*p))) ------------------ | Branch (31376:9): [True: 0, False: 137k] ------------------ 31377| 0| janet_panic("invalid format (width or precision too long)"); 31378| | 31379| | /* Write to form - replace characters with fixed size stuff */ 31380| 137k| *(form++) = '%'; 31381| 137k| const char *p2 = strfrmt; 31382| 275k| while (p2 <= p) { ------------------ | Branch (31382:12): [True: 137k, False: 137k] ------------------ 31383| 137k| char *loc = strchr(FMT_REPLACE_INTTYPES, *p2); ------------------ | |31323| 137k|#define FMT_REPLACE_INTTYPES "diouxX" ------------------ 31384| 137k| if (loc != NULL && *loc != '\0') { ------------------ | Branch (31384:13): [True: 1.05k, False: 136k] | Branch (31384:28): [True: 1.05k, False: 0] ------------------ 31385| 1.05k| const char *mapping = get_fmt_mapping(*p2++); 31386| 1.05k| size_t len = strlen(mapping); 31387| 1.05k| memcpy(form, mapping, len); 31388| 1.05k| form += len; 31389| 136k| } else { 31390| 136k| *(form++) = *(p2++); 31391| 136k| } 31392| 137k| } 31393| 137k| *form = '\0'; 31394| | 31395| 137k| return p; 31396| 137k|} janet.c:get_fmt_mapping: 31344| 1.05k|static const char *get_fmt_mapping(char c) { 31345| 3.17k| for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) { ------------------ | Branch (31345:24): [True: 3.17k, False: 0] ------------------ 31346| 3.17k| if (format_mappings[i].c == c) ------------------ | Branch (31346:13): [True: 1.05k, False: 2.11k] ------------------ 31347| 1.05k| return format_mappings[i].mapping; 31348| 3.17k| } 31349| 0| janet_assert(0, "bad format mapping"); ------------------ | | 389| 0|#define janet_assert(c, m) do { \ | | 390| 0| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, Folded] | | ------------------ | | 391| 0|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 0] | | ------------------ ------------------ 31350| 0|} janet.c:pushtypes: 31300| 2.14k|static void pushtypes(JanetBuffer *buffer, int types) { 31301| 2.14k| int first = 1; 31302| 2.14k| int i = 0; 31303| 27.9k| while (types) { ------------------ | Branch (31303:12): [True: 25.7k, False: 2.14k] ------------------ 31304| 25.7k| if (1 & types) { ------------------ | Branch (31304:13): [True: 17.1k, False: 8.59k] ------------------ 31305| 17.1k| if (first) { ------------------ | Branch (31305:17): [True: 2.14k, False: 15.0k] ------------------ 31306| 2.14k| first = 0; 31307| 15.0k| } else { 31308| 15.0k| janet_buffer_push_cstring(buffer, (types == 1) ? " or " : ", "); ------------------ | Branch (31308:51): [True: 2.14k, False: 12.8k] ------------------ 31309| 15.0k| } 31310| 17.1k| janet_buffer_push_cstring(buffer, janet_type_names[i]); 31311| 17.1k| } 31312| 25.7k| i++; 31313| 25.7k| types >>= 1; 31314| 25.7k| } 31315| 2.14k|} janet.c:pushchunk: 31792| 569k|static void pushchunk(JanetcRegisterAllocator *ra) { 31793| | /* Registers 240-255 are always allocated (reserved) */ 31794| 569k| uint32_t chunk = ra->count == 7 ? 0xFFFF0000 : 0; ------------------ | Branch (31794:22): [True: 1.22k, False: 568k] ------------------ 31795| 569k| int32_t newcount = ra->count + 1; 31796| 569k| if (newcount > ra->capacity) { ------------------ | Branch (31796:9): [True: 170k, False: 399k] ------------------ 31797| 170k| int32_t newcapacity = newcount * 2; 31798| 170k| ra->chunks = janet_realloc(ra->chunks, (size_t) newcapacity * sizeof(uint32_t)); ------------------ | | 2409| 170k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 31799| 170k| if (!ra->chunks) { ------------------ | Branch (31799:13): [True: 0, False: 170k] ------------------ 31800| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 31801| 0| } 31802| 170k| ra->capacity = newcapacity; 31803| 170k| } 31804| 569k| ra->chunks[ra->count] = chunk; 31805| 569k| ra->count = newcount; 31806| 569k|} janet.c:janetc_def: 32666| 101k|static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) { 32667| 101k| JanetCompiler *c = opts.compiler; 32668| 101k| JanetTable *attr_table = handleattr(c, "def", argn, argv); 32669| 101k| if (c->result.status == JANET_COMPILE_ERROR) { ------------------ | Branch (32669:9): [True: 1, False: 101k] ------------------ 32670| 1| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 1|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32671| 1| } 32672| 101k| check_metadata_lint(c, attr_table); 32673| 101k| opts.flags &= ~JANET_FOPTS_HINT; ------------------ | | 1148| 101k|#define JANET_FOPTS_HINT 0x20000 ------------------ 32674| 101k| SlotHeadPair *into = NULL; 32675| 101k| into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]); 32676| 101k| if (c->result.status == JANET_COMPILE_ERROR) { ------------------ | Branch (32676:9): [True: 1.17k, False: 100k] ------------------ 32677| 1.17k| janet_v_free(into); ------------------ | | 756| 1.17k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 1.17k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 1.17k, False: 0] | | ------------------ ------------------ 32678| 1.17k| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 1.17k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.17k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.17k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.17k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32679| 1.17k| } 32680| 100k| JanetSlot ret = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 100k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 100k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 100k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 100k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32681| 385k| for (int32_t i = 0; i < janet_v_count(into); i++) { ------------------ | | 759| 385k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 385k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 385k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 385k, False: 3] | | ------------------ ------------------ | Branch (32681:25): [True: 285k, False: 100k] ------------------ 32682| 285k| destructure(c, into[i].lhs, into[i].rhs, defleaf, attr_table); 32683| 285k| ret = into[i].rhs; 32684| 285k| } 32685| | janet_v_free(into); ------------------ | | 756| 100k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 100k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 100k, False: 3] | | ------------------ ------------------ 32686| 100k| return ret; 32687| 101k|} janet.c:handleattr: 32418| 102k|static JanetTable *handleattr(JanetCompiler *c, const char *kind, int32_t argn, const Janet *argv) { 32419| 102k| int32_t i; 32420| 102k| if (argn < 2) { ------------------ | Branch (32420:9): [True: 0, False: 102k] ------------------ 32421| 0| janetc_error(c, janet_formatc("expected at least 2 arguments to %s", kind)); 32422| 0| return NULL; 32423| 0| } 32424| 102k| JanetTable *tab = janet_table(2); 32425| 102k| const char *binding_name = janet_type(argv[0]) == JANET_SYMBOL ------------------ | | 795| 102k| (isnan((x).number) \ | | 796| 102k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 102k| : JANET_NUMBER) ------------------ | Branch (32425:32): [True: 99.6k, False: 2.85k] | Branch (32425:32): [True: 98.1k, False: 4.32k] ------------------ 32426| 102k| ? ((const char *)janet_unwrap_symbol(argv[0])) ------------------ | | 864| 98.1k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 32427| 102k| : ""; 32428| 492k| for (i = 1; i < argn - 1; i++) { ------------------ | Branch (32428:17): [True: 390k, False: 102k] ------------------ 32429| 390k| Janet attr = argv[i]; 32430| 390k| switch (janet_type(attr)) { ------------------ | | 795| 390k| (isnan((x).number) \ | | 796| 390k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 390k| : JANET_NUMBER) ------------------ | Branch (32430:17): [True: 390k, False: 0] ------------------ 32431| 106| case JANET_TUPLE: ------------------ | Branch (32431:13): [True: 106, False: 390k] ------------------ 32432| 106| janetc_cerror(c, "unexpected form - did you intend to use defn?"); 32433| 106| break; 32434| 20| default: ------------------ | Branch (32434:13): [True: 20, False: 390k] ------------------ 32435| 20| janetc_error(c, janet_formatc("cannot add metadata %v to binding %s", attr, binding_name)); 32436| 20| break; 32437| 2| case JANET_KEYWORD: ------------------ | Branch (32437:13): [True: 2, False: 390k] ------------------ 32438| 2| janet_table_put(tab, attr, janet_wrap_true()); ------------------ | | 832| 2|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 2| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32439| 2| break; 32440| 390k| case JANET_STRING: ------------------ | Branch (32440:13): [True: 390k, False: 128] ------------------ 32441| 390k| janet_table_put(tab, janet_ckeywordv("doc"), attr); ------------------ | | 1843| 390k|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 390k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 390k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 390k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 390k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32442| 390k| break; 32443| 0| case JANET_STRUCT: ------------------ | Branch (32443:13): [True: 0, False: 390k] ------------------ 32444| 0| janet_table_merge_struct(tab, janet_unwrap_struct(attr)); ------------------ | | 857| 0|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 32445| 0| break; 32446| 390k| } 32447| 390k| } 32448| 102k| return tab; 32449| 102k|} janet.c:check_metadata_lint: 32589| 102k|static void check_metadata_lint(JanetCompiler *c, JanetTable *attr_table) { 32590| 102k| if (!(c->scope->flags & JANET_SCOPE_TOP) && attr_table && attr_table->count) { ------------------ | | 1060| 102k|#define JANET_SCOPE_TOP 4 ------------------ | Branch (32590:9): [True: 102k, False: 70] | Branch (32590:49): [True: 102k, False: 0] | Branch (32590:63): [True: 0, False: 102k] ------------------ 32591| | /* A macro is a normal lint, other metadata is a strict lint */ 32592| 0| if (janet_truthy(janet_table_get_keyword(attr_table, "macro"))) { ------------------ | | 818| 0| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:5): [True: 0, False: 0] | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 0| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ 32593| 0| janetc_lintf(c, JANET_C_LINT_NORMAL, "macro tag is ignored in inner scopes"); 32594| 0| } 32595| 0| } 32596| 102k|} janet.c:destructure: 32249| 2.27M| JanetTable *attr) { 32250| 2.27M| if (c->recursion_guard <= 0) { ------------------ | Branch (32250:9): [True: 98, False: 2.27M] ------------------ 32251| 98| janetc_error(c, janet_cstring("C stack recursed too deeply")); 32252| 98| return 1; 32253| 98| } 32254| 2.27M| switch (janet_type(left)) { ------------------ | | 795| 2.27M| (isnan((x).number) \ | | 796| 2.27M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 2.27M| : JANET_NUMBER) ------------------ | Branch (32254:13): [True: 2.26M, False: 7.30k] ------------------ 32255| 73.6k| default: ------------------ | Branch (32255:9): [True: 73.6k, False: 2.20M] ------------------ 32256| 73.6k| janetc_error(c, janet_formatc("unexpected type in destructuring, got %v", left)); 32257| 73.6k| return 1; 32258| 1.28M| case JANET_SYMBOL: ------------------ | Branch (32258:9): [True: 1.28M, False: 993k] ------------------ 32259| | /* Leaf, assign right to left */ 32260| 1.28M| return leaf(c, janet_unwrap_symbol(left), right, attr); ------------------ | | 864| 1.28M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 32261| 919k| case JANET_TUPLE: ------------------ | Branch (32261:9): [True: 919k, False: 1.35M] ------------------ 32262| 919k| case JANET_ARRAY: { ------------------ | Branch (32262:9): [True: 183, False: 2.27M] ------------------ 32263| 919k| int32_t len = 0; 32264| 919k| const Janet *values = NULL; 32265| 919k| janet_indexed_view(left, &values, &len); 32266| 2.86M| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (32266:33): [True: 1.94M, False: 919k] ------------------ 32267| 1.94M| JanetSlot nextright = janetc_farslot(c); 32268| 1.94M| Janet subval = values[i]; 32269| | 32270| 1.94M| if (janet_checktype(subval, JANET_SYMBOL) && !janet_cstrcmp(janet_unwrap_symbol(subval), "&")) { ------------------ | | 806| 3.88M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.17M, False: 766k] | | | Branch (806:6): [Folded, False: 1.94M] | | ------------------ | | 807| 3.88M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.88M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.94M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.94M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.94M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.94M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(subval, JANET_SYMBOL) && !janet_cstrcmp(janet_unwrap_symbol(subval), "&")) { ------------------ | | 864| 1.17M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ | Branch (32270:62): [True: 78, False: 1.17M] ------------------ 32271| 78| if (i + 1 >= len) { ------------------ | Branch (32271:25): [True: 26, False: 52] ------------------ 32272| 26| janetc_cerror(c, "expected symbol following '& in destructuring pattern"); 32273| 26| return 1; 32274| 26| } 32275| | 32276| 52| if (i + 2 < len) { ------------------ | Branch (32276:25): [True: 6, False: 46] ------------------ 32277| 6| int32_t num_extra = len - i - 1; 32278| 6| Janet *extra = janet_tuple_begin(num_extra); 32279| 6| janet_tuple_flag(extra) |= JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1806| 6|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 6|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_flag(extra) |= JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1798| 6|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ 32280| | 32281| 6.97k| for (int32_t j = 0; j < num_extra; ++j) { ------------------ | Branch (32281:45): [True: 6.96k, False: 6] ------------------ 32282| 6.96k| extra[j] = values[j + i + 1]; 32283| 6.96k| } 32284| | 32285| 6| janetc_error(c, janet_formatc("expected a single symbol follow '& in destructuring pattern, found %q", janet_wrap_tuple(janet_tuple_end(extra)))); ------------------ | | 843| 6|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 6| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32286| 6| return 1; 32287| 6| } 32288| | 32289| 46| if (!janet_checktype(values[i + 1], JANET_SYMBOL)) { ------------------ | | 806| 46| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 46] | | ------------------ | | 807| 46| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 46| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 46| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 46|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 46|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 46|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32289:25): [True: 42, False: 4] ------------------ 32290| 42| janetc_error(c, janet_formatc("expected symbol following '& in destructuring pattern, found %q", values[i + 1])); 32291| 42| return 1; 32292| 42| } 32293| | 32294| 4| JanetSlot argi = janetc_farslot(c); 32295| 4| JanetSlot arg = janetc_farslot(c); 32296| 4| JanetSlot len = janetc_farslot(c); 32297| | 32298| 4| janetc_emit_si(c, JOP_LOAD_INTEGER, argi, i, 0); 32299| 4| janetc_emit_ss(c, JOP_LENGTH, len, right, 0); 32300| | 32301| | /* loop condition - reuse arg slot for the condition result */ 32302| 4| int32_t label_loop_start = janetc_emit_sss(c, JOP_LESS_THAN, arg, argi, len, 0); 32303| 4| int32_t label_loop_cond_jump = janetc_emit_si(c, JOP_JUMP_IF_NOT, arg, 0, 0); 32304| | 32305| | /* loop body */ 32306| 4| janetc_emit_sss(c, JOP_GET, arg, right, argi, 0); 32307| 4| janetc_emit_s(c, JOP_PUSH, arg, 0); 32308| 4| janetc_emit_ssi(c, JOP_ADD_IMMEDIATE, argi, argi, 1, 0); 32309| | 32310| | /* loop - jump back to the start of the loop */ 32311| 4| int32_t label_loop_loop = janet_v_count(c->buffer); ------------------ | | 759| 4|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 4|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 4|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 4, False: 0] | | ------------------ ------------------ 32312| 4| janetc_emit(c, JOP_JUMP); 32313| 4| int32_t label_loop_exit = janet_v_count(c->buffer); ------------------ | | 759| 4|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 4|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 4|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 4, False: 0] | | ------------------ ------------------ 32314| | 32315| | /* avoid shifting negative numbers */ 32316| 4| check_16bit_jump(c, label_loop_cond_jump, label_loop_exit); 32317| 4| check_24bit_jump(c, label_loop_start, label_loop_loop); 32318| 4| c->buffer[label_loop_cond_jump] |= (uint32_t)(label_loop_exit - label_loop_cond_jump) << 16; 32319| 4| c->buffer[label_loop_loop] |= (uint32_t)(label_loop_start - label_loop_loop) << 8; 32320| | 32321| 4| janetc_freeslot(c, argi); 32322| 4| janetc_freeslot(c, arg); 32323| 4| janetc_freeslot(c, len); 32324| | 32325| 4| janetc_emit_s(c, JOP_MAKE_TUPLE, nextright, 1); 32326| | 32327| 4| leaf(c, janet_unwrap_symbol(values[i + 1]), nextright, attr); ------------------ | | 864| 4|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 32328| 4| janetc_freeslot(c, nextright); 32329| 4| break; 32330| 46| } 32331| | 32332| 1.94M| if (i < 0x100) { ------------------ | Branch (32332:21): [True: 1.87M, False: 71.2k] ------------------ 32333| 1.87M| janetc_emit_ssu(c, JOP_GET_INDEX, nextright, right, (uint8_t) i, 1); 32334| 1.87M| } else { 32335| 71.2k| JanetSlot k = janetc_cslot(janet_wrap_integer(i)); ------------------ | | 967| 71.2k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 71.2k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 32336| 71.2k| janetc_emit_sss(c, JOP_IN, nextright, right, k, 1); 32337| 71.2k| } 32338| 1.94M| c->recursion_guard--; 32339| 1.94M| if (destructure(c, subval, nextright, leaf, attr)) ------------------ | Branch (32339:21): [True: 1.94M, False: 0] ------------------ 32340| 1.94M| janetc_freeslot(c, nextright); 32341| 1.94M| c->recursion_guard++; 32342| 1.94M| } 32343| 919k| } 32344| 919k| return 1; 32345| 122| case JANET_TABLE: ------------------ | Branch (32345:9): [True: 122, False: 2.27M] ------------------ 32346| 205| case JANET_STRUCT: { ------------------ | Branch (32346:9): [True: 83, False: 2.27M] ------------------ 32347| 205| const JanetKV *kvs = NULL; 32348| 205| int32_t cap = 0, len = 0; 32349| 205| janet_dictionary_view(left, &kvs, &len, &cap); 32350| 1.44k| for (int32_t i = 0; i < cap; i++) { ------------------ | Branch (32350:33): [True: 1.23k, False: 205] ------------------ 32351| 1.23k| if (janet_checktype(kvs[i].key, JANET_NIL)) continue; ------------------ | | 806| 1.23k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 920, False: 318] | | | Branch (806:6): [Folded, False: 1.23k] | | ------------------ | | 807| 1.23k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.23k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.23k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.23k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.23k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.23k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32352| 318| JanetSlot nextright = janetc_farslot(c); 32353| 318| JanetSlot k = janetc_value(janetc_fopts_default(c), kvs[i].key); 32354| 318| janetc_emit_sss(c, JOP_IN, nextright, right, k, 1); 32355| 318| c->recursion_guard--; 32356| 318| if (destructure(c, kvs[i].value, nextright, leaf, attr)) ------------------ | Branch (32356:21): [True: 318, False: 0] ------------------ 32357| 318| janetc_freeslot(c, nextright); 32358| 318| c->recursion_guard++; 32359| 318| } 32360| 205| } 32361| 205| return 1; 32362| 2.27M| } 32363| 2.27M|} janet.c:check_16bit_jump: 32114| 3.57k|static void check_16bit_jump(JanetCompiler *c, int32_t lab1, int32_t lab2) { 32115| 3.57k| if (bad_16bit_jump(lab1, lab2)) { ------------------ | Branch (32115:9): [True: 24, False: 3.54k] ------------------ 32116| 24| janetc_cerror(c, "bad 16-bit jump, too large"); 32117| 24| } 32118| 3.57k|} janet.c:bad_16bit_jump: 32108| 3.57k|static int bad_16bit_jump(int32_t lab1, int32_t lab2) { 32109| 3.57k| if (lab2 - lab1 > INT16_MAX) return 1; ------------------ | Branch (32109:9): [True: 24, False: 3.54k] ------------------ 32110| 3.54k| if (lab2 - lab1 < INT16_MIN) return 1; ------------------ | Branch (32110:9): [True: 0, False: 3.54k] ------------------ 32111| 3.54k| return 0; 32112| 3.54k|} janet.c:check_24bit_jump: 32126| 2.90k|static void check_24bit_jump(JanetCompiler *c, int32_t lab1, int32_t lab2) { 32127| 2.90k| if (bad_24bit_jump(lab1, lab2)) { ------------------ | Branch (32127:9): [True: 0, False: 2.90k] ------------------ 32128| 0| janetc_cerror(c, "bad 24-bit jump, too large"); 32129| 0| } 32130| 2.90k|} janet.c:bad_24bit_jump: 32120| 2.90k|static int bad_24bit_jump(int32_t lab1, int32_t lab2) { 32121| 2.90k| if (lab2 - lab1 > 0xFFFFFF) return 1; ------------------ | Branch (32121:9): [True: 0, False: 2.90k] ------------------ 32122| 2.90k| if (lab2 - lab1 < -0x1000000) return 1; ------------------ | Branch (32122:9): [True: 0, False: 2.90k] ------------------ 32123| 2.90k| return 0; 32124| 2.90k|} janet.c:defleaf: 32624| 1.28M| JanetTable *tab) { 32625| 1.28M| JanetTable *entry = NULL; 32626| 1.28M| int is_redef = 0; 32627| 1.28M| if (c->scope->flags & JANET_SCOPE_TOP) { ------------------ | | 1060| 1.28M|#define JANET_SCOPE_TOP 4 ------------------ | Branch (32627:9): [True: 162, False: 1.27M] ------------------ 32628| 162| entry = janet_table_clone(tab); 32629| 162| janet_table_put(entry, janet_ckeywordv("source-map"), ------------------ | | 1843| 162|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 162|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 162| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32630| 162| janet_wrap_tuple(janetc_make_sourcemap(c))); ------------------ | | 843| 162|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 162| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32631| | 32632| 162| is_redef = c->is_redef; 32633| 162| if (is_redef) janet_table_put(entry, janet_ckeywordv("redef"), janet_wrap_true()); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (is_redef) janet_table_put(entry, janet_ckeywordv("redef"), janet_wrap_true()); ------------------ | | 832| 0|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32633:13): [True: 0, False: 162] ------------------ 32634| | 32635| 162| if (is_redef) { ------------------ | Branch (32635:13): [True: 0, False: 162] ------------------ 32636| 0| JanetBinding binding = janet_resolve_ext(c->env, sym); 32637| 0| JanetArray *ref; 32638| 0| if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) { ------------------ | Branch (32638:17): [True: 0, False: 0] | Branch (32638:62): [True: 0, False: 0] ------------------ 32639| 0| ref = janet_unwrap_array(binding.value); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 32640| 0| } else { 32641| 0| ref = janet_array(1); 32642| 0| janet_array_push(ref, janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32643| 0| } 32644| 0| janet_table_put(entry, janet_ckeywordv("ref"), janet_wrap_array(ref)); ------------------ | | 1843| 0|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ janet_table_put(entry, janet_ckeywordv("ref"), janet_wrap_array(ref)); ------------------ | | 845| 0|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32645| 0| JanetSlot refslot = janetc_cslot(janet_wrap_array(ref)); ------------------ | | 845| 0|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32646| 0| janetc_emit_ssu(c, JOP_PUT_INDEX, refslot, s, 0, 0); 32647| 162| } else { 32648| 162| JanetSlot valsym = janetc_cslot(janet_ckeywordv("value")); ------------------ | | 1843| 162|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 162|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 162| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32649| 162| JanetSlot tabslot = janetc_cslot(janet_wrap_table(entry)); ------------------ | | 846| 162|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 162| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32650| 162| janetc_emit_sss(c, JOP_PUT, tabslot, valsym, s, 0); 32651| 162| } 32652| 162| } 32653| 1.28M| int no_unused = tab && tab->count && janet_truthy(janet_table_get_keyword(tab, "unused")); ------------------ | | 818| 1.28M| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 324| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 162] | | | | ------------------ | | | | 807| 324| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 324| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 162| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 162|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 162] | | ------------------ | | 819| 1.28M| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (32653:21): [True: 1.13M, False: 140k] | Branch (32653:28): [True: 162, False: 1.13M] ------------------ 32654| 1.28M| int no_shadow = is_redef || (tab && tab->count && janet_truthy(janet_table_get_keyword(tab, "shadow"))); ------------------ | | 818| 162| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 324| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 162] | | | | ------------------ | | | | 807| 324| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 324| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 162| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 162|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 162] | | ------------------ | | 819| 162| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (32654:21): [True: 0, False: 1.28M] | Branch (32654:34): [True: 1.13M, False: 140k] | Branch (32654:41): [True: 162, False: 1.13M] ------------------ 32655| 1.28M| uint32_t def_flags = 0; 32656| 1.28M| if (no_unused) def_flags |= JANET_DEFFLAG_NO_UNUSED; ------------------ | | 1183| 0|#define JANET_DEFFLAG_NO_UNUSED 2 ------------------ | Branch (32656:9): [True: 0, False: 1.28M] ------------------ 32657| 1.28M| if (no_shadow) def_flags |= JANET_DEFFLAG_NO_SHADOWCHECK; ------------------ | | 1182| 0|#define JANET_DEFFLAG_NO_SHADOWCHECK 1 ------------------ | Branch (32657:9): [True: 0, False: 1.28M] ------------------ 32658| 1.28M| int result = namelocal(c, sym, 0, s, def_flags); 32659| 1.28M| if (entry) { ------------------ | Branch (32659:9): [True: 162, False: 1.27M] ------------------ 32660| | /* Add env entry to env AFTER namelocal to avoid the shadowcheck false positive */ 32661| 162| janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry)); ------------------ | | 849| 162|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 162| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry)); ------------------ | | 846| 162|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 162| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 162|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 162|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32662| 162| } 32663| 1.28M| return result; 32664| 1.28M|} janet.c:janetc_make_sourcemap: 32366| 2.34k|static const Janet *janetc_make_sourcemap(JanetCompiler *c) { 32367| 2.34k| Janet *tup = janet_tuple_begin(3); 32368| 2.34k| tup[0] = c->source ? janet_wrap_string(c->source) : janet_wrap_nil(); ------------------ | | 848| 2.34k|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 2.34k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.34k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.34k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ tup[0] = c->source ? janet_wrap_string(c->source) : janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2.34k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32368:14): [True: 2.34k, False: 0] ------------------ 32369| 2.34k| tup[1] = janet_wrap_integer(c->current_mapping.line); ------------------ | | 967| 2.34k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 2.34k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 32370| 2.34k| tup[2] = janet_wrap_integer(c->current_mapping.column); ------------------ | | 967| 2.34k|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 2.34k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 32371| 2.34k| return janet_tuple_end(tup); 32372| 2.34k|} janet.c:namelocal: 32522| 1.28M|static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, JanetSlot ret, uint32_t def_flags) { 32523| 1.28M| int isUnnamedRegister = !(ret.flags & JANET_SLOT_NAMED) && ------------------ | | 1039| 1.28M|#define JANET_SLOT_NAMED 0x20000 ------------------ | Branch (32523:29): [True: 1.27M, False: 1.06k] ------------------ 32524| 1.27M| ret.index > 0 && ------------------ | Branch (32524:29): [True: 1.17M, False: 102k] ------------------ 32525| 1.17M| ret.envindex >= 0; ------------------ | Branch (32525:29): [True: 0, False: 1.17M] ------------------ 32526| | /* optimization for `(def x my-def)` - don't emit a movn/movf instruction, we can just alias my-def */ 32527| | /* TODO - implement optimization for `(def x my-var)` correctly as well w/ de-aliasing */ 32528| 1.28M| int canAlias = !(flags & JANET_SLOT_MUTABLE) && ------------------ | | 1040| 1.28M|#define JANET_SLOT_MUTABLE 0x40000 ------------------ | Branch (32528:20): [True: 1.28M, False: 757] ------------------ 32529| 1.28M| !(ret.flags & JANET_SLOT_MUTABLE) && ------------------ | | 1040| 1.28M|#define JANET_SLOT_MUTABLE 0x40000 ------------------ | Branch (32529:20): [True: 1.27M, False: 905] ------------------ 32530| 1.27M| (ret.flags & JANET_SLOT_NAMED) && ------------------ | | 1039| 1.27M|#define JANET_SLOT_NAMED 0x20000 ------------------ | Branch (32530:20): [True: 161, False: 1.27M] ------------------ 32531| 161| (ret.index >= 0) && ------------------ | Branch (32531:20): [True: 161, False: 0] ------------------ 32532| 161| (ret.envindex == -1); ------------------ | Branch (32532:20): [True: 161, False: 0] ------------------ 32533| 1.28M| if (canAlias) { ------------------ | Branch (32533:9): [True: 161, False: 1.28M] ------------------ 32534| 161| ret.flags &= ~JANET_SLOT_MUTABLE; ------------------ | | 1040| 161|#define JANET_SLOT_MUTABLE 0x40000 ------------------ 32535| 161| isUnnamedRegister = 1; /* don't free slot after use - is an alias for another slot */ 32536| 1.28M| } else if (!isUnnamedRegister) { ------------------ | Branch (32536:16): [True: 1.28M, False: 0] ------------------ 32537| | /* Slot is not able to be named */ 32538| 1.28M| JanetSlot localslot = janetc_farslot(c); 32539| 1.28M| janetc_copy(c, localslot, ret); 32540| 1.28M| ret = localslot; 32541| 1.28M| } 32542| 1.28M| ret.flags |= flags; 32543| 1.28M| if (c->scope->flags & JANET_SCOPE_TOP) { ------------------ | | 1060| 1.28M|#define JANET_SCOPE_TOP 4 ------------------ | Branch (32543:9): [True: 162, False: 1.28M] ------------------ 32544| 162| def_flags |= JANET_DEFFLAG_NO_UNUSED; ------------------ | | 1183| 162|#define JANET_DEFFLAG_NO_UNUSED 2 ------------------ 32545| 162| } 32546| 1.28M| janetc_nameslot(c, head, ret, def_flags); 32547| 1.28M| return !isUnnamedRegister; 32548| 1.28M|} janet.c:janetc_do: 32826| 8.68k|static JanetSlot janetc_do(JanetFopts opts, int32_t argn, const Janet *argv) { 32827| 8.68k| int32_t i; 32828| 8.68k| JanetSlot ret = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 8.68k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 8.68k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 8.68k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.68k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32829| 8.68k| JanetCompiler *c = opts.compiler; 32830| 8.68k| JanetFopts subopts = janetc_fopts_default(c); 32831| 8.68k| JanetScope tempscope; 32832| 8.68k| janetc_scope(&tempscope, c, 0, "do"); 32833| 514k| for (i = 0; i < argn; i++) { ------------------ | Branch (32833:17): [True: 505k, False: 8.68k] ------------------ 32834| 505k| if (i != argn - 1) { ------------------ | Branch (32834:13): [True: 497k, False: 8.68k] ------------------ 32835| 497k| subopts.flags = JANET_FOPTS_DROP; ------------------ | | 1149| 497k|#define JANET_FOPTS_DROP 0x40000 ------------------ 32836| 497k| } else { 32837| 8.68k| subopts = opts; 32838| 8.68k| subopts.flags &= ~JANET_FOPTS_ACCEPT_SPLICE; ------------------ | | 1150| 8.68k|#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 ------------------ 32839| 8.68k| } 32840| 505k| ret = janetc_value(subopts, argv[i]); 32841| 505k| if (i != argn - 1) { ------------------ | Branch (32841:13): [True: 497k, False: 8.68k] ------------------ 32842| 497k| janetc_freeslot(c, ret); 32843| 497k| } 32844| 505k| } 32845| 8.68k| janetc_popscope_keepslot(c, ret); 32846| 8.68k| return ret; 32847| 8.68k|} janet.c:janetc_fn: 33083| 146k|static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) { 33084| 146k| JanetCompiler *c = opts.compiler; 33085| 146k| JanetFuncDef *def; 33086| 146k| JanetSlot ret; 33087| 146k| Janet head; 33088| 146k| JanetScope fnscope; 33089| 146k| int32_t paramcount, argi, parami, arity, min_arity = 0, max_arity, defindex, i; 33090| 146k| JanetFopts subopts = janetc_fopts_default(c); 33091| 146k| const Janet *params; 33092| 146k| const char *errmsg = NULL; 33093| | 33094| | /* Function flags */ 33095| 146k| int vararg = 0; 33096| 146k| int structarg = 0; 33097| 146k| int allow_extra = 0; 33098| 146k| int selfref = 0; 33099| 146k| int hasname = 0; 33100| 146k| int seenamp = 0; 33101| 146k| int seenopt = 0; 33102| 146k| int namedargs = 0; 33103| | 33104| | /* Begin function */ 33105| 146k| c->scope->flags |= JANET_SCOPE_CLOSURE; ------------------ | | 1062| 146k|#define JANET_SCOPE_CLOSURE 16 ------------------ 33106| 146k| janetc_scope(&fnscope, c, JANET_SCOPE_FUNCTION, "function"); ------------------ | | 1058| 146k|#define JANET_SCOPE_FUNCTION 1 ------------------ 33107| | 33108| 146k| if (argn == 0) { ------------------ | Branch (33108:9): [True: 0, False: 146k] ------------------ 33109| 0| errmsg = "expected at least 1 argument to function literal"; 33110| 0| goto error; 33111| 0| } 33112| | 33113| | /* Read function parameters */ 33114| 146k| parami = 0; 33115| 146k| head = argv[0]; 33116| 146k| if (janet_checktype(head, JANET_SYMBOL)) { ------------------ | | 806| 146k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 792, False: 145k] | | | Branch (806:6): [Folded, False: 146k] | | ------------------ | | 807| 146k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 146k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 146k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 146k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 146k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 146k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33117| 792| selfref = 1; 33118| 792| hasname = 1; 33119| 792| parami = 1; 33120| 145k| } else if (janet_checktype(head, JANET_KEYWORD)) { ------------------ | | 806| 145k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 143k, False: 2.25k] | | | Branch (806:6): [Folded, False: 145k] | | ------------------ | | 807| 145k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 145k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 145k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 145k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 145k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 145k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33121| 143k| hasname = 1; 33122| 143k| parami = 1; 33123| 143k| } 33124| 146k| if (parami >= argn || !janet_checktype(argv[parami], JANET_TUPLE)) { ------------------ | | 806| 146k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 146k] | | ------------------ | | 807| 146k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 146k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 146k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 146k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 146k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 146k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33124:9): [True: 0, False: 146k] | Branch (33124:27): [True: 330, False: 145k] ------------------ 33125| 330| errmsg = "expected function parameters"; 33126| 330| goto error; 33127| 330| } 33128| | 33129| | /* Keep track of destructured parameters */ 33130| 145k| JanetSlot *destructed_params = NULL; 33131| 145k| JanetSlot *named_params = NULL; 33132| 145k| JanetTable *named_table = NULL; 33133| 145k| JanetSlot named_slot; 33134| | 33135| | /* Compile function parameters */ 33136| 145k| params = janet_unwrap_tuple(argv[parami]); ------------------ | | 858| 145k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 33137| 145k| paramcount = janet_tuple_length(params); ------------------ | | 1802| 145k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 145k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 33138| 145k| arity = paramcount; 33139| 196k| for (i = 0; i < paramcount; i++) { ------------------ | Branch (33139:17): [True: 50.5k, False: 145k] ------------------ 33140| 50.5k| Janet param = params[i]; 33141| 50.5k| if (namedargs) { ------------------ | Branch (33141:13): [True: 0, False: 50.5k] ------------------ 33142| 0| arity--; 33143| 0| if (!janet_checktype(param, JANET_SYMBOL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33143:17): [True: 0, False: 0] ------------------ 33144| 0| errmsg = "only named arguments can follow &named"; 33145| 0| goto error; 33146| 0| } 33147| 0| Janet key = janet_wrap_keyword(janet_unwrap_symbol(param)); ------------------ | | 850| 0|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33148| 0| janet_table_put(named_table, key, param); 33149| 0| janet_v_push(named_params, janetc_farslot(c)); ------------------ | | 757| 0|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 0|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 0|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 0|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 0] | | | | | | | Branch (768:50): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 0|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 0|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 33150| 50.5k| } else if (janet_checktype(param, JANET_SYMBOL)) { ------------------ | | 806| 50.5k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.64k, False: 45.8k] | | | Branch (806:6): [Folded, False: 50.5k] | | ------------------ | | 807| 50.5k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 50.5k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 50.5k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 50.5k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 50.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33151| | /* Check for varargs and unfixed arity */ 33152| 4.64k| const uint8_t *sym = janet_unwrap_symbol(param); ------------------ | | 864| 4.64k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 33153| 4.64k| if (sym[0] == '&') { ------------------ | Branch (33153:17): [True: 17, False: 4.63k] ------------------ 33154| 17| if (!janet_cstrcmp(sym, "&")) { ------------------ | Branch (33154:21): [True: 17, False: 0] ------------------ 33155| 17| if (seenamp) { ------------------ | Branch (33155:25): [True: 0, False: 17] ------------------ 33156| 0| errmsg = "& in unexpected location"; 33157| 0| goto error; 33158| 17| } else if (i == paramcount - 1) { ------------------ | Branch (33158:32): [True: 0, False: 17] ------------------ 33159| 0| allow_extra = 1; 33160| 0| arity--; 33161| 17| } else if (i == paramcount - 2) { ------------------ | Branch (33161:32): [True: 17, False: 0] ------------------ 33162| 17| vararg = 1; 33163| 17| arity -= 2; 33164| 17| } else { 33165| 0| errmsg = "& in unexpected location"; 33166| 0| goto error; 33167| 0| } 33168| 17| seenamp = 1; 33169| 17| } else if (!janet_cstrcmp(sym, "&opt")) { ------------------ | Branch (33169:28): [True: 0, False: 0] ------------------ 33170| 0| if (seenopt) { ------------------ | Branch (33170:25): [True: 0, False: 0] ------------------ 33171| 0| errmsg = "only one &opt allowed"; 33172| 0| goto error; 33173| 0| } else if (i == paramcount - 1) { ------------------ | Branch (33173:32): [True: 0, False: 0] ------------------ 33174| 0| errmsg = "&opt cannot be last item in parameter list"; 33175| 0| goto error; 33176| 0| } 33177| 0| min_arity = i; 33178| 0| arity--; 33179| 0| seenopt = 1; 33180| 0| } else if (!janet_cstrcmp(sym, "&keys")) { ------------------ | Branch (33180:28): [True: 0, False: 0] ------------------ 33181| 0| if (seenamp) { ------------------ | Branch (33181:25): [True: 0, False: 0] ------------------ 33182| 0| errmsg = "&keys in unexpected location"; 33183| 0| goto error; 33184| 0| } else if (i == paramcount - 2) { ------------------ | Branch (33184:32): [True: 0, False: 0] ------------------ 33185| 0| vararg = 1; 33186| 0| structarg = 1; 33187| 0| arity -= 2; 33188| 0| } else { 33189| 0| errmsg = "&keys in unexpected location"; 33190| 0| goto error; 33191| 0| } 33192| 0| seenamp = 1; 33193| 0| } else if (!janet_cstrcmp(sym, "&named")) { ------------------ | Branch (33193:28): [True: 0, False: 0] ------------------ 33194| 0| if (seenamp) { ------------------ | Branch (33194:25): [True: 0, False: 0] ------------------ 33195| 0| errmsg = "&named in unexpected location"; 33196| 0| goto error; 33197| 0| } 33198| 0| vararg = 1; 33199| 0| structarg = 1; 33200| 0| arity--; 33201| 0| seenamp = 1; 33202| 0| namedargs = 1; 33203| 0| named_table = janet_table(10); 33204| 0| named_slot = janetc_farslot(c); 33205| 0| } else { 33206| 0| janetc_nameslot(c, sym, janetc_farslot(c), 0); 33207| 0| } 33208| 4.63k| } else { 33209| 4.63k| janetc_nameslot(c, sym, janetc_farslot(c), 0); 33210| 4.63k| } 33211| 45.8k| } else { 33212| 45.8k| janet_v_push(destructed_params, janetc_farslot(c)); ------------------ | | 757| 45.8k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 45.8k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 45.8k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 45.6k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 45.6k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 45.6k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 45.6k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 221, False: 45.6k] | | | | | | | Branch (768:50): [True: 167, False: 45.4k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 388|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 45.8k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 45.8k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 33213| 45.8k| } 33214| 50.5k| } 33215| | 33216| | /* Compile named arguments */ 33217| 145k| if (namedargs) { ------------------ | Branch (33217:9): [True: 0, False: 145k] ------------------ 33218| 0| Janet param = janet_wrap_table(named_table); ------------------ | | 846| 0|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33219| 0| destructure(c, param, named_slot, defleaf, NULL); 33220| 0| janetc_freeslot(c, named_slot); 33221| 0| janet_v_free(named_params); ------------------ | | 756| 0|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 0, False: 0] | | ------------------ ------------------ 33222| 0| } 33223| | 33224| | /* Compile destructed params */ 33225| 145k| int32_t j = 0; 33226| 196k| for (i = 0; i < paramcount; i++) { ------------------ | Branch (33226:17): [True: 50.5k, False: 145k] ------------------ 33227| 50.5k| Janet param = params[i]; 33228| 50.5k| if (!janet_checktype(param, JANET_SYMBOL)) { ------------------ | | 806| 50.5k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 50.5k] | | ------------------ | | 807| 50.5k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 50.5k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 50.5k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 50.5k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 50.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 50.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (33228:13): [True: 45.8k, False: 4.64k] ------------------ 33229| 45.8k| janet_assert(janet_v_count(destructed_params) > j, "out of bounds"); ------------------ | | 389| 45.8k|#define janet_assert(c, m) do { \ | | 390| 91.7k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 45.8k] | | | Branch (390:11): [True: 45.8k, False: 0] | | ------------------ | | 391| 45.8k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 45.8k] | | ------------------ ------------------ 33230| 45.8k| JanetSlot reg = destructed_params[j++]; 33231| 45.8k| destructure(c, param, reg, defleaf, NULL); 33232| 45.8k| janetc_freeslot(c, reg); 33233| 45.8k| } 33234| 50.5k| } 33235| 145k| janet_v_free(destructed_params); ------------------ | | 756| 145k|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 221|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 221, False: 145k] | | ------------------ ------------------ 33236| | 33237| 145k| max_arity = (vararg || allow_extra) ? INT32_MAX : arity; ------------------ | Branch (33237:18): [True: 17, False: 145k] | Branch (33237:28): [True: 0, False: 145k] ------------------ 33238| 145k| if (!seenopt) min_arity = arity; ------------------ | Branch (33238:9): [True: 145k, False: 0] ------------------ 33239| | 33240| | /* Check for self ref (also avoid if arguments shadow own name) */ 33241| 145k| if (selfref) { ------------------ | Branch (33241:9): [True: 792, False: 145k] ------------------ 33242| | /* Check if the parameters shadow the function name. If so, don't 33243| | * emit JOP_LOAD_SELF and add a binding since that most users 33244| | * seem to expect that function parameters take precedence over the 33245| | * function name */ 33246| 792| const uint8_t *sym = janet_unwrap_symbol(head); ------------------ | | 864| 792|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 33247| 792| int32_t len = janet_v_count(c->scope->syms); ------------------ | | 759| 792|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 9|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 9|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 9, False: 783] | | ------------------ ------------------ 33248| 792| int found = 0; 33249| 1.05k| for (int32_t i = 0; i < len; i++) { ------------------ | Branch (33249:29): [True: 266, False: 792] ------------------ 33250| 266| if (c->scope->syms[i].sym == sym) { ------------------ | Branch (33250:17): [True: 0, False: 266] ------------------ 33251| 0| found = 1; 33252| 0| } 33253| 266| } 33254| 792| if (!found) { ------------------ | Branch (33254:13): [True: 792, False: 0] ------------------ 33255| 792| JanetSlot slot = janetc_farslot(c); 33256| 792| slot.flags = JANET_SLOT_NAMED | JANET_FUNCTION; ------------------ | | 1039| 792|#define JANET_SLOT_NAMED 0x20000 ------------------ 33257| 792| janetc_emit_s(c, JOP_LOAD_SELF, slot, 1); 33258| | /* We should figure out a better way to avoid `(def x 1) (def x :shadow (fn x [...] ...))` triggering a 33259| | * shadow lint for the last x */ 33260| 792| janetc_nameslot(c, sym, slot, JANET_DEFFLAG_NO_UNUSED | JANET_DEFFLAG_NO_SHADOWCHECK); ------------------ | | 1183| 792|#define JANET_DEFFLAG_NO_UNUSED 2 ------------------ janetc_nameslot(c, sym, slot, JANET_DEFFLAG_NO_UNUSED | JANET_DEFFLAG_NO_SHADOWCHECK); ------------------ | | 1182| 792|#define JANET_DEFFLAG_NO_SHADOWCHECK 1 ------------------ 33261| 792| } 33262| 792| } 33263| | 33264| | /* Compile function body */ 33265| 145k| if (parami + 1 == argn) { ------------------ | Branch (33265:9): [True: 0, False: 145k] ------------------ 33266| 0| janetc_emit(c, JOP_RETURN_NIL); 33267| 145k| } else { 33268| 390k| for (argi = parami + 1; argi < argn; argi++) { ------------------ | Branch (33268:33): [True: 259k, False: 131k] ------------------ 33269| 259k| subopts.flags = (argi == (argn - 1)) ? JANET_FOPTS_TAIL : JANET_FOPTS_DROP; ------------------ | | 1147| 145k|#define JANET_FOPTS_TAIL 0x10000 ------------------ subopts.flags = (argi == (argn - 1)) ? JANET_FOPTS_TAIL : JANET_FOPTS_DROP; ------------------ | | 1149| 373k|#define JANET_FOPTS_DROP 0x40000 ------------------ | Branch (33269:29): [True: 145k, False: 113k] ------------------ 33270| 259k| janetc_value(subopts, argv[argi]); 33271| 259k| if (c->result.status == JANET_COMPILE_ERROR) ------------------ | Branch (33271:17): [True: 14.6k, False: 244k] ------------------ 33272| 14.6k| goto error2; 33273| 259k| } 33274| 145k| } 33275| | 33276| | /* Build function */ 33277| 131k| JanetString name = hasname ? janet_unwrap_symbol(head) : NULL; ------------------ | | 864| 129k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ | Branch (33277:24): [True: 129k, False: 1.80k] ------------------ 33278| 131k| def = janetc_pop_funcdef(c, name); 33279| 131k| def->arity = arity; 33280| 131k| def->min_arity = min_arity; 33281| 131k| def->max_arity = max_arity; 33282| 131k| if (named_table != NULL) { ------------------ | Branch (33282:9): [True: 0, False: 131k] ------------------ 33283| 0| def->named_args_count = named_table->count; 33284| 0| } 33285| 131k| if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG; ------------------ | | 1097| 3|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ | Branch (33285:9): [True: 3, False: 131k] ------------------ 33286| 131k| if (structarg) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG; ------------------ | | 1105| 0|#define JANET_FUNCDEF_FLAG_STRUCTARG 0x1000000 ------------------ | Branch (33286:9): [True: 0, False: 131k] ------------------ 33287| 131k| if (namedargs) def->flags |= JANET_FUNCDEF_FLAG_NAMEDARGS; ------------------ | | 1107| 0|#define JANET_FUNCDEF_FLAG_NAMEDARGS 0x4000000 ------------------ | Branch (33287:9): [True: 0, False: 131k] ------------------ 33288| | 33289| 131k| janet_def_addflags(def); 33290| 131k| defindex = janetc_addfuncdef(c, def); 33291| | 33292| | /* Ensure enough slots for vararg function. */ 33293| 131k| if (arity + vararg > def->slotcount) def->slotcount = arity + vararg; ------------------ | Branch (33293:9): [True: 0, False: 131k] ------------------ 33294| | 33295| | /* Do basic optimization */ 33296| 131k| if (!(fnscope.flags & JANET_SCOPE_UNUSED)) { ------------------ | | 1061| 131k|#define JANET_SCOPE_UNUSED 8 ------------------ | Branch (33296:9): [True: 131k, False: 0] ------------------ 33297| 131k| janet_bytecode_optimize(def, c->optimize); 33298| 131k| } 33299| | 33300| | /* Instantiate closure */ 33301| 131k| ret = janetc_gettarget(opts); 33302| 131k| janetc_emit_su(c, JOP_CLOSURE, ret, defindex, 1); 33303| 131k| return ret; 33304| | 33305| 330|error: 33306| 330| janetc_cerror(c, errmsg); 33307| 14.9k|error2: 33308| 14.9k| janetc_popscope(c); 33309| 14.9k| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 14.9k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 14.9k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 14.9k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 14.9k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33310| 330|} janet.c:janetc_addfuncdef: 32872| 131k|static int32_t janetc_addfuncdef(JanetCompiler *c, JanetFuncDef *def) { 32873| 131k| JanetScope *scope = c->scope; 32874| 162k| while (scope) { ------------------ | Branch (32874:12): [True: 162k, False: 0] ------------------ 32875| 162k| if (scope->flags & JANET_SCOPE_FUNCTION) ------------------ | | 1058| 162k|#define JANET_SCOPE_FUNCTION 1 ------------------ | Branch (32875:13): [True: 131k, False: 30.9k] ------------------ 32876| 131k| break; 32877| 30.9k| scope = scope->parent; 32878| 30.9k| } 32879| 131k| janet_assert(scope, "could not add funcdef"); ------------------ | | 389| 131k|#define janet_assert(c, m) do { \ | | 390| 131k| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 131k] | | ------------------ | | 391| 131k|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 131k] | | ------------------ ------------------ 32880| 131k| janet_v_push(scope->defs, def); ------------------ | | 757| 131k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 131k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 131k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 51.1k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 51.1k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 51.1k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 51.1k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 80.8k, False: 51.1k] | | | | | | | Branch (768:50): [True: 3.21k, False: 47.9k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 84.0k|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 131k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 131k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 32881| | return janet_v_count(scope->defs) - 1; ------------------ | | 759| 131k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 131k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 131k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 131k, False: 0] | | ------------------ ------------------ 32882| 131k|} janet.c:janetc_if: 32720| 3.69k|static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) { 32721| 3.69k| JanetCompiler *c = opts.compiler; 32722| 3.69k| int32_t labelr, labeljr, labeld, labeljd; 32723| 3.69k| JanetFopts condopts, bodyopts; 32724| 3.69k| JanetSlot cond, left, right, target; 32725| 3.69k| Janet truebody, falsebody; 32726| 3.69k| JanetScope condscope, tempscope; 32727| 3.69k| const int tail = opts.flags & JANET_FOPTS_TAIL; ------------------ | | 1147| 3.69k|#define JANET_FOPTS_TAIL 0x10000 ------------------ 32728| 3.69k| const int drop = opts.flags & JANET_FOPTS_DROP; ------------------ | | 1149| 3.69k|#define JANET_FOPTS_DROP 0x40000 ------------------ 32729| 3.69k| uint8_t ifnjmp = JOP_JUMP_IF_NOT; 32730| | 32731| 3.69k| if (argn < 2 || argn > 3) { ------------------ | Branch (32731:9): [True: 0, False: 3.69k] | Branch (32731:21): [True: 0, False: 3.69k] ------------------ 32732| 0| janetc_cerror(c, "expected 2 or 3 arguments to if"); 32733| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32734| 0| } 32735| | 32736| | /* Get the bodies of the if expression */ 32737| 3.69k| truebody = argv[1]; 32738| 3.69k| falsebody = argn > 2 ? argv[2] : janet_wrap_nil(); ------------------ | | 831| 2.98k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 6.67k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2.98k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.98k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32738:17): [True: 717, False: 2.98k] ------------------ 32739| | 32740| | /* Get options */ 32741| 3.69k| condopts = janetc_fopts_default(c); 32742| 3.69k| bodyopts = opts; 32743| 3.69k| bodyopts.flags &= ~JANET_FOPTS_ACCEPT_SPLICE; ------------------ | | 1150| 3.69k|#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 ------------------ 32744| | 32745| | /* Set target for compilation */ 32746| 3.69k| target = (drop || tail) ------------------ | Branch (32746:15): [True: 16, False: 3.68k] | Branch (32746:23): [True: 922, False: 2.75k] ------------------ 32747| 3.69k| ? janetc_cslot(janet_wrap_nil()) ------------------ | | 831| 938|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 938| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 938|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 938|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32748| 3.69k| : janetc_gettarget(opts); 32749| | 32750| | /* Compile condition */ 32751| 3.69k| janetc_scope(&condscope, c, 0, "if"); 32752| | 32753| 3.69k| Janet condform = argv[0]; 32754| 3.69k| if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) { ------------------ | | 1017| 3.69k|#define JANET_FUN_EQ 24 ------------------ | Branch (32754:9): [True: 0, False: 3.69k] ------------------ 32755| 0| ifnjmp = JOP_JUMP_IF_NOT_NIL; 32756| 3.69k| } else if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) { ------------------ | | 1018| 3.69k|#define JANET_FUN_NEQ 25 ------------------ | Branch (32756:16): [True: 0, False: 3.69k] ------------------ 32757| 0| ifnjmp = JOP_JUMP_IF_NIL; 32758| 0| } 32759| | 32760| 3.69k| cond = janetc_value(condopts, condform); 32761| | 32762| | /* Check constant condition. */ 32763| | /* TODO: Use type info for more short circuits */ 32764| 3.69k| if (cond.flags & JANET_SLOT_CONSTANT) { ------------------ | | 1038| 3.69k|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (32764:9): [True: 260, False: 3.43k] ------------------ 32765| 260| int swap_condition = 0; 32766| 260| if (ifnjmp == JOP_JUMP_IF_NOT && !janet_truthy(cond.constant)) swap_condition = 1; ------------------ | | 818| 260| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 520| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 260] | | | | ------------------ | | | | 807| 520| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 520| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 260| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 260|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 260|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 260|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 133, False: 127] | | ------------------ | | 819| 260| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 266| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 133] | | | | ------------------ | | | | 807| 266| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 266| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 133| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 133|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 133|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 133|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 133, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (32766:13): [True: 260, False: 0] ------------------ 32767| 260| if (ifnjmp == JOP_JUMP_IF_NIL && janet_checktype(cond.constant, JANET_NIL)) swap_condition = 1; ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32767:13): [True: 0, False: 260] ------------------ 32768| 260| if (ifnjmp == JOP_JUMP_IF_NOT_NIL && !janet_checktype(cond.constant, JANET_NIL)) swap_condition = 1; ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32768:13): [True: 0, False: 260] | Branch (32768:46): [True: 0, False: 0] ------------------ 32769| 260| if (swap_condition) { ------------------ | Branch (32769:13): [True: 127, False: 133] ------------------ 32770| | /* Swap the true and false bodies */ 32771| 127| Janet temp = falsebody; 32772| 127| falsebody = truebody; 32773| 127| truebody = temp; 32774| 127| } 32775| 260| janetc_scope(&tempscope, c, 0, "if-true"); 32776| 260| right = janetc_value(bodyopts, truebody); 32777| 260| if (!drop && !tail) janetc_copy(c, target, right); ------------------ | Branch (32777:13): [True: 252, False: 8] | Branch (32777:22): [True: 0, False: 252] ------------------ 32778| 260| janetc_popscope(c); 32779| 260| if (!janet_checktype(falsebody, JANET_NIL)) { ------------------ | | 806| 260| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 260] | | ------------------ | | 807| 260| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 260| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 260| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 260|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 260|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 260|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32779:13): [True: 256, False: 4] ------------------ 32780| 256| janetc_throwaway(bodyopts, falsebody); 32781| 256| } 32782| 260| janetc_popscope(c); 32783| 260| return target; 32784| 260| } 32785| | 32786| | /* Compile jump to right */ 32787| 3.43k| labeljr = janetc_emit_si(c, ifnjmp, cond, 0, 0); 32788| | 32789| | /* Condition left body */ 32790| 3.43k| janetc_scope(&tempscope, c, 0, "if-true"); 32791| 3.43k| left = janetc_value(bodyopts, truebody); 32792| 3.43k| if (!drop && !tail) janetc_copy(c, target, left); ------------------ | Branch (32792:9): [True: 3.42k, False: 8] | Branch (32792:18): [True: 2.75k, False: 670] ------------------ 32793| 3.43k| janetc_popscope(c); 32794| | 32795| | /* Compile jump to done */ 32796| 3.43k| labeljd = janet_v_count(c->buffer); ------------------ | | 759| 3.43k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3.43k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.43k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3.43k, False: 0] | | ------------------ ------------------ 32797| 3.43k| if (!tail && !(drop && janet_checktype(falsebody, JANET_NIL))) janetc_emit(c, JOP_JUMP); ------------------ | | 806| 8| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 8] | | | Branch (806:6): [Folded, False: 8] | | ------------------ | | 807| 8| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 8| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 8| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 8|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 8|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32797:9): [True: 2.76k, False: 670] | Branch (32797:20): [True: 8, False: 2.75k] ------------------ 32798| | 32799| | /* Compile right body */ 32800| 3.43k| labelr = janet_v_count(c->buffer); ------------------ | | 759| 3.43k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3.43k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.43k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3.43k, False: 0] | | ------------------ ------------------ 32801| 3.43k| janetc_scope(&tempscope, c, 0, "if-false"); 32802| 3.43k| right = janetc_value(bodyopts, falsebody); 32803| 3.43k| if (!drop && !tail) janetc_copy(c, target, right); ------------------ | Branch (32803:9): [True: 3.42k, False: 8] | Branch (32803:18): [True: 2.75k, False: 670] ------------------ 32804| 3.43k| janetc_popscope(c); 32805| | 32806| | /* Pop main scope */ 32807| 3.43k| janetc_popscope(c); 32808| | 32809| | /* Write jumps - only add jump lengths if jump actually emitted */ 32810| 3.43k| labeld = janet_v_count(c->buffer); ------------------ | | 759| 3.43k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 3.43k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.43k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 3.43k, False: 0] | | ------------------ ------------------ 32811| 3.43k| if (labeljr < labeld) { ------------------ | Branch (32811:9): [True: 3.43k, False: 0] ------------------ 32812| 3.43k| check_16bit_jump(c, labeljr, labelr); 32813| 3.43k| c->buffer[labeljr] |= (uint32_t)(labelr - labeljr) << 16; 32814| 3.43k| if (!tail && labeljd < labeld) { ------------------ | Branch (32814:13): [True: 2.76k, False: 670] | Branch (32814:22): [True: 2.76k, False: 0] ------------------ 32815| 2.76k| check_24bit_jump(c, labeljd, labeld); 32816| 2.76k| c->buffer[labeljd] |= (uint32_t)(labeld - labeljd) << 8; 32817| 2.76k| } 32818| 3.43k| } 32819| | 32820| 3.43k| if (tail) target.flags |= JANET_SLOT_RETURNED; ------------------ | | 1042| 670|#define JANET_SLOT_RETURNED 0x100000 ------------------ | Branch (32820:9): [True: 670, False: 2.76k] ------------------ 32821| 3.43k| return target; 32822| 3.69k|} janet.c:janetc_check_nil_form: 32690| 8.90k|static int janetc_check_nil_form(Janet x, Janet *capture, uint32_t fun_tag) { 32691| 8.90k| if (!janet_checktype(x, JANET_TUPLE)) return 0; ------------------ | | 806| 8.90k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 8.90k] | | ------------------ | | 807| 8.90k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 8.90k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 8.90k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 8.90k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 8.90k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.90k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32691:9): [True: 7.06k, False: 1.83k] ------------------ 32692| 1.83k| JanetTuple tup = janet_unwrap_tuple(x); ------------------ | | 858| 1.83k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 32693| 1.83k| if (3 != janet_tuple_length(tup)) return 0; ------------------ | | 1802| 1.83k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 1.83k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (32693:9): [True: 162, False: 1.67k] ------------------ 32694| 1.67k| Janet op1 = tup[0]; 32695| 1.67k| if (!janet_checktype(op1, JANET_FUNCTION)) return 0; ------------------ | | 806| 1.67k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 1.67k] | | ------------------ | | 807| 1.67k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.67k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.67k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.67k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.67k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.67k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32695:9): [True: 168, False: 1.50k] ------------------ 32696| 1.50k| JanetFunction *fun = janet_unwrap_function(op1); ------------------ | | 868| 1.50k|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 32697| 1.50k| uint32_t tag = fun->def->flags & JANET_FUNCDEF_FLAG_TAG; ------------------ | | 1108| 1.50k|#define JANET_FUNCDEF_FLAG_TAG 0xFFFF ------------------ 32698| 1.50k| if (tag != fun_tag) return 0; ------------------ | Branch (32698:9): [True: 753, False: 753] ------------------ 32699| 753| if (janet_checktype(tup[1], JANET_NIL)) { ------------------ | | 806| 753| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 753, False: 0] | | | Branch (806:6): [Folded, False: 753] | | ------------------ | | 807| 753| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 753| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 753| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 753|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 753|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 753|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32700| 753| *capture = tup[2]; 32701| 753| return 1; 32702| 753| } else if (janet_checktype(tup[2], JANET_NIL)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32703| 0| *capture = tup[1]; 32704| 0| return 1; 32705| 0| } 32706| 0| return 0; 32707| 753|} janet.c:janetc_quasiquote: 32224| 98.1k|static JanetSlot janetc_quasiquote(JanetFopts opts, int32_t argn, const Janet *argv) { 32225| 98.1k| if (argn != 1) { ------------------ | Branch (32225:9): [True: 0, False: 98.1k] ------------------ 32226| 0| janetc_cerror(opts.compiler, "expected 1 argument to quasiquote"); 32227| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32228| 0| } 32229| 98.1k| return quasiquote(opts, argv[0], opts.compiler->recursion_guard, 0); 32230| 98.1k|} janet.c:quasiquote: 32163| 3.32M|static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) { 32164| 3.32M| if (depth == 0) { ------------------ | Branch (32164:9): [True: 52, False: 3.32M] ------------------ 32165| 52| janetc_cerror(opts.compiler, "quasiquote too deeply nested"); 32166| 52| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 52|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 52| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 52|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 52|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32167| 52| } 32168| 3.32M| JanetSlot *slots = NULL; 32169| 3.32M| JanetFopts subopts = opts; 32170| 3.32M| subopts.flags &= ~JANET_FOPTS_HINT; ------------------ | | 1148| 3.32M|#define JANET_FOPTS_HINT 0x20000 ------------------ 32171| 3.32M| switch (janet_type(x)) { ------------------ | | 795| 3.32M| (isnan((x).number) \ | | 796| 3.32M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 3.32M| : JANET_NUMBER) ------------------ | Branch (32171:13): [True: 3.17M, False: 149k] ------------------ 32172| 1.81M| default: ------------------ | Branch (32172:9): [True: 1.81M, False: 1.50M] ------------------ 32173| 1.81M| return janetc_cslot(x); 32174| 1.50M| case JANET_TUPLE: { ------------------ | Branch (32174:9): [True: 1.50M, False: 1.81M] ------------------ 32175| 1.50M| int32_t i, len; 32176| 1.50M| const Janet *tup = janet_unwrap_tuple(x); ------------------ | | 858| 1.50M|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 32177| 1.50M| len = janet_tuple_length(tup); ------------------ | | 1802| 1.50M|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 1.50M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ 32178| 1.50M| if (len > 1 && janet_checktype(tup[0], JANET_SYMBOL)) { ------------------ | | 806| 1.50M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.50M, False: 736] | | | Branch (806:6): [Folded, False: 1.50M] | | ------------------ | | 807| 1.50M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.50M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.50M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.50M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.50M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.50M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (32178:17): [True: 1.50M, False: 82] ------------------ 32179| 1.50M| const uint8_t *head = janet_unwrap_symbol(tup[0]); ------------------ | | 864| 1.50M|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 32180| 1.50M| if (!janet_cstrcmp(head, "unquote")) { ------------------ | Branch (32180:21): [True: 47, False: 1.50M] ------------------ 32181| 47| if (level == 0) { ------------------ | Branch (32181:25): [True: 3, False: 44] ------------------ 32182| 3| JanetFopts subopts = janetc_fopts_default(opts.compiler); 32183| 3| subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE; ------------------ | | 1150| 3|#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 ------------------ 32184| 3| return janetc_value(subopts, tup[1]); 32185| 44| } else { 32186| 44| level--; 32187| 44| } 32188| 1.50M| } else if (!janet_cstrcmp(head, "quasiquote")) { ------------------ | Branch (32188:28): [True: 26.8k, False: 1.47M] ------------------ 32189| 26.8k| level++; 32190| 26.8k| } 32191| 1.50M| } 32192| 4.71M| for (i = 0; i < len; i++) ------------------ | Branch (32192:25): [True: 3.21M, False: 1.50M] ------------------ 32193| 3.21M| janet_v_push(slots, quasiquote(subopts, tup[i], depth - 1, level)); ------------------ | | 757| 4.71M|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 3.21M|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 3.21M|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 1.70M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.70M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 1.70M|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 1.70M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 1.50M, False: 1.70M] | | | | | | | Branch (768:50): [True: 1.50M, False: 198k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 3.01M|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 3.21M|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 3.21M|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 32194| 1.50M| return qq_slots(opts, slots, (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) ------------------ | | 1806| 1.50M|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 1.50M|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ return qq_slots(opts, slots, (janet_tuple_flag(tup) & JANET_TUPLE_FLAG_BRACKETCTOR) ------------------ | | 1798| 1.50M|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ | Branch (32194:42): [True: 82, False: 1.50M] ------------------ 32195| 1.50M| ? JOP_MAKE_BRACKET_TUPLE 32196| 1.50M| : JOP_MAKE_TUPLE); 32197| 1.50M| } 32198| 3| case JANET_ARRAY: { ------------------ | Branch (32198:9): [True: 3, False: 3.32M] ------------------ 32199| 3| int32_t i; 32200| 3| JanetArray *array = janet_unwrap_array(x); ------------------ | | 860| 3|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 32201| 12.0k| for (i = 0; i < array->count; i++) ------------------ | Branch (32201:25): [True: 12.0k, False: 3] ------------------ 32202| 12.0k| janet_v_push(slots, quasiquote(subopts, array->data[i], depth - 1, level)); ------------------ | | 757| 12.0k|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 12.0k|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 12.0k|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 12.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 12.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 12.0k|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 12.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 3, False: 12.0k] | | | | | | | Branch (768:50): [True: 14, False: 12.0k] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 17|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 12.0k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 12.0k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 32203| 3| return qq_slots(opts, slots, JOP_MAKE_ARRAY); 32204| 1.50M| } 32205| 39| case JANET_TABLE: ------------------ | Branch (32205:9): [True: 39, False: 3.32M] ------------------ 32206| 45| case JANET_STRUCT: { ------------------ | Branch (32206:9): [True: 6, False: 3.32M] ------------------ 32207| 45| const JanetKV *kv = NULL, *kvs = NULL; 32208| 45| int32_t len, cap = 0; 32209| 45| janet_dictionary_view(x, &kvs, &len, &cap); 32210| 214| while ((kv = janet_dictionary_next(kvs, cap, kv))) { ------------------ | Branch (32210:20): [True: 169, False: 45] ------------------ 32211| 169| JanetSlot key = quasiquote(subopts, kv->key, depth - 1, level); 32212| 169| JanetSlot value = quasiquote(subopts, kv->value, depth - 1, level); 32213| 169| key.flags &= ~JANET_SLOT_SPLICED; ------------------ | | 1046| 169|#define JANET_SLOT_SPLICED 0x1000000 ------------------ 32214| 169| value.flags &= ~JANET_SLOT_SPLICED; ------------------ | | 1046| 169|#define JANET_SLOT_SPLICED 0x1000000 ------------------ 32215| 169| janet_v_push(slots, key); ------------------ | | 757| 169|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 169|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 169|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 128|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 128|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 128|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 128|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 41, False: 128] | | | | | | | Branch (768:50): [True: 40, False: 88] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 81|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 169|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 169|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 32216| 169| janet_v_push(slots, value); ------------------ | | 757| 169|#define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 769| 169|#define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 768| 169|#define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 766| 169|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | | | | | ------------------ | | | | | | | | | | 764| 169|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define janet_v__needgrow(v, n) ((v) == NULL || janet_v__cnt(v) + (n) >= janet_v__cap(v)) | | | | | | ------------------ | | | | | | | | 765| 169|#define janet_v__cap(v) janet_v__raw(v)[0] | | | | | | | | ------------------ | | | | | | | | | | 764| 169|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (768:35): [True: 0, False: 169] | | | | | | | Branch (768:50): [True: 120, False: 49] | | | | | | ------------------ | | | | ------------------ | | | | #define janet_v__maybegrow(v, n) (janet_v__needgrow((v), (n)) ? janet_v__grow((v), (n)) : 0) | | | | ------------------ | | | | | | 770| 120|#define janet_v__grow(v, n) ((v) = janet_v_grow((v), (n), sizeof(*(v)))) | | | | ------------------ | | ------------------ | | #define janet_v_push(v, x) (janet_v__maybegrow(v, 1), (v)[janet_v__cnt(v)++] = (x)) | | ------------------ | | | | 766| 169|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 169|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ ------------------ 32217| 169| } 32218| 45| return qq_slots(opts, slots, 32219| 45| janet_checktype(x, JANET_TABLE) ? JOP_MAKE_TABLE : JOP_MAKE_STRUCT); ------------------ | | 806| 45| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 39, False: 6] | | | Branch (806:6): [Folded, False: 45] | | ------------------ | | 807| 45| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 45| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 45| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 45|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 45|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 45|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32220| 39| } 32221| 3.32M| } 32222| 3.32M|} janet.c:qq_slots: 32155| 1.50M|static JanetSlot qq_slots(JanetFopts opts, JanetSlot *slots, int makeop) { 32156| 1.50M| JanetSlot target = janetc_gettarget(opts); 32157| 1.50M| janetc_pushslots(opts.compiler, slots); 32158| 1.50M| janetc_freeslots(opts.compiler, slots); 32159| 1.50M| janetc_emit_s(opts.compiler, makeop, target, 1); 32160| 1.50M| return target; 32161| 1.50M|} janet.c:janetc_quote: 32132| 13.1k|static JanetSlot janetc_quote(JanetFopts opts, int32_t argn, const Janet *argv) { 32133| 13.1k| if (argn != 1) { ------------------ | Branch (32133:9): [True: 0, False: 13.1k] ------------------ 32134| 0| janetc_cerror(opts.compiler, "expected 1 argument to quote"); 32135| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32136| 0| } 32137| 13.1k| return janetc_cslot(argv[0]); 32138| 13.1k|} janet.c:janetc_varset: 32374| 2.24k|static JanetSlot janetc_varset(JanetFopts opts, int32_t argn, const Janet *argv) { 32375| 2.24k| if (argn != 2) { ------------------ | Branch (32375:9): [True: 0, False: 2.24k] ------------------ 32376| 0| janetc_cerror(opts.compiler, "expected 2 arguments to set"); 32377| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32378| 0| } 32379| 2.24k| JanetFopts subopts = janetc_fopts_default(opts.compiler); 32380| 2.24k| if (janet_checktype(argv[0], JANET_SYMBOL)) { ------------------ | | 806| 2.24k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.86k, False: 379] | | | Branch (806:6): [Folded, False: 2.24k] | | ------------------ | | 807| 2.24k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2.24k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 2.24k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 2.24k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 2.24k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.24k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32381| | /* Normal var - (set a 1) */ 32382| 1.86k| const uint8_t *sym = janet_unwrap_symbol(argv[0]); ------------------ | | 864| 1.86k|#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x)) ------------------ 32383| 1.86k| JanetSlot dest = janetc_resolve(opts.compiler, sym); 32384| 1.86k| if (!(dest.flags & JANET_SLOT_MUTABLE)) { ------------------ | | 1040| 1.86k|#define JANET_SLOT_MUTABLE 0x40000 ------------------ | Branch (32384:13): [True: 0, False: 1.86k] ------------------ 32385| 0| janetc_cerror(opts.compiler, "cannot set constant"); 32386| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32387| 0| } 32388| 1.86k| subopts.flags = JANET_FOPTS_HINT; ------------------ | | 1148| 1.86k|#define JANET_FOPTS_HINT 0x20000 ------------------ 32389| 1.86k| subopts.hint = dest; 32390| 1.86k| JanetSlot ret = janetc_value(subopts, argv[1]); 32391| 1.86k| janetc_copy(opts.compiler, dest, ret); 32392| 1.86k| return ret; 32393| 1.86k| } else if (janet_checktype(argv[0], JANET_TUPLE)) { ------------------ | | 806| 379| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 376, False: 3] | | | Branch (806:6): [Folded, False: 379] | | ------------------ | | 807| 379| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 379| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 379| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 379|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 379|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 379|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32394| | /* Set a field (setf behavior) - (set (tab :key) 2) */ 32395| 376| const Janet *tup = janet_unwrap_tuple(argv[0]); ------------------ | | 858| 376|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 32396| | /* Tuple must have 2 elements */ 32397| 376| if (janet_tuple_length(tup) != 2) { ------------------ | | 1802| 376|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 376|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (32397:13): [True: 0, False: 376] ------------------ 32398| 0| janetc_cerror(opts.compiler, "expected 2 element tuple for l-value to set"); 32399| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32400| 0| } 32401| 376| JanetSlot ds = janetc_value(subopts, tup[0]); 32402| 376| JanetSlot key = janetc_value(subopts, tup[1]); 32403| | /* Can't be tail position because we will emit a PUT instruction afterwards */ 32404| | /* Also can't drop either */ 32405| 376| opts.flags &= ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); ------------------ | | 1147| 376|#define JANET_FOPTS_TAIL 0x10000 ------------------ opts.flags &= ~(JANET_FOPTS_TAIL | JANET_FOPTS_DROP); ------------------ | | 1149| 376|#define JANET_FOPTS_DROP 0x40000 ------------------ 32406| 376| JanetSlot rvalue = janetc_value(opts, argv[1]); 32407| | /* Emit the PUT instruction */ 32408| 376| janetc_emit_sss(opts.compiler, JOP_PUT, ds, key, rvalue, 0); 32409| 376| return rvalue; 32410| 376| } else { 32411| | /* Error */ 32412| 3| janetc_cerror(opts.compiler, "expected symbol or tuple for l-value to set"); 32413| 3| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 3|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 3| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 3|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32414| 3| } 32415| 2.24k|} janet.c:janetc_splice: 32140| 108k|static JanetSlot janetc_splice(JanetFopts opts, int32_t argn, const Janet *argv) { 32141| 108k| JanetSlot ret; 32142| 108k| if (!(opts.flags & JANET_FOPTS_ACCEPT_SPLICE)) { ------------------ | | 1150| 108k|#define JANET_FOPTS_ACCEPT_SPLICE 0x80000 ------------------ | Branch (32142:9): [True: 534, False: 108k] ------------------ 32143| 534| janetc_cerror(opts.compiler, "splice can only be used in function parameters and data constructors, it has no effect here"); 32144| 534| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 534|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 534| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 534|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 534|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32145| 534| } 32146| 108k| if (argn != 1) { ------------------ | Branch (32146:9): [True: 0, False: 108k] ------------------ 32147| 0| janetc_cerror(opts.compiler, "expected 1 argument to splice"); 32148| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32149| 0| } 32150| 108k| ret = janetc_value(opts, argv[0]); 32151| 108k| ret.flags |= JANET_SLOT_SPLICED; ------------------ | | 1046| 108k|#define JANET_SLOT_SPLICED 0x1000000 ------------------ 32152| 108k| return ret; 32153| 108k|} janet.c:janetc_unquote: 32232| 22.5k|static JanetSlot janetc_unquote(JanetFopts opts, int32_t argn, const Janet *argv) { 32233| 22.5k| (void) argn; 32234| 22.5k| (void) argv; 32235| 22.5k| janetc_cerror(opts.compiler, "cannot use unquote here"); 32236| 22.5k| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 22.5k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 22.5k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 22.5k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 22.5k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32237| 22.5k|} janet.c:janetc_var: 32598| 813|static JanetSlot janetc_var(JanetFopts opts, int32_t argn, const Janet *argv) { 32599| 813| JanetCompiler *c = opts.compiler; 32600| 813| JanetTable *attr_table = handleattr(c, "var", argn, argv); 32601| 813| if (c->result.status == JANET_COMPILE_ERROR) { ------------------ | Branch (32601:9): [True: 7, False: 806] ------------------ 32602| 7| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 7|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 7| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 7|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32603| 7| } 32604| 806| check_metadata_lint(c, attr_table); 32605| 806| SlotHeadPair *into = NULL; 32606| 806| into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]); 32607| 806| if (c->result.status == JANET_COMPILE_ERROR) { ------------------ | Branch (32607:9): [True: 0, False: 806] ------------------ 32608| 0| janet_v_free(into); ------------------ | | 756| 0|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 0|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 0, False: 0] | | ------------------ ------------------ 32609| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32610| 0| } 32611| 806| JanetSlot ret = janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 806|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 806| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 806|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 806|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32612| 1.61k| for (int32_t i = 0; i < janet_v_count(into); i++) { ------------------ | | 759| 1.61k|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 1.61k|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 1.61k|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 1.61k, False: 0] | | ------------------ ------------------ | Branch (32612:25): [True: 806, False: 806] ------------------ 32613| 806| destructure(c, into[i].lhs, into[i].rhs, varleaf, attr_table); 32614| 806| ret = into[i].rhs; 32615| 806| } 32616| | janet_v_free(into); ------------------ | | 756| 806|#define janet_v_free(v) (((v) != NULL) ? (janet_sfree(janet_v__raw(v)), 0) : 0) | | ------------------ | | | | 764| 806|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ | | | Branch (756:34): [True: 806, False: 0] | | ------------------ ------------------ 32617| 806| return ret; 32618| 806|} janet.c:varleaf: 32554| 2.94k| JanetTable *reftab) { 32555| 2.94k| if (c->scope->flags & JANET_SCOPE_TOP) { ------------------ | | 1060| 2.94k|#define JANET_SCOPE_TOP 4 ------------------ | Branch (32555:9): [True: 2.18k, False: 757] ------------------ 32556| | /* Global var, generate var */ 32557| 2.18k| JanetSlot refslot; 32558| 2.18k| JanetTable *entry = janet_table_clone(reftab); 32559| | 32560| 2.18k| int is_redef = c->is_redef; 32561| | 32562| 2.18k| JanetArray *ref; 32563| 2.18k| JanetBinding old_binding; 32564| 2.18k| if (is_redef && (old_binding = janet_resolve_ext(c->env, sym), ------------------ | Branch (32564:13): [True: 0, False: 2.18k] | Branch (32564:25): [True: 0, False: 0] ------------------ 32565| 0| old_binding.type == JANET_BINDING_VAR)) { 32566| 0| ref = janet_unwrap_array(old_binding.value); ------------------ | | 860| 0|#define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x)) ------------------ 32567| 2.18k| } else { 32568| 2.18k| ref = janet_array(1); 32569| 2.18k| janet_array_push(ref, janet_wrap_nil()); ------------------ | | 831| 2.18k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 2.18k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32570| 2.18k| } 32571| | 32572| 2.18k| janet_table_put(entry, janet_ckeywordv("ref"), janet_wrap_array(ref)); ------------------ | | 1843| 2.18k|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 2.18k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 2.18k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ janet_table_put(entry, janet_ckeywordv("ref"), janet_wrap_array(ref)); ------------------ | | 845| 2.18k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 2.18k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32573| 2.18k| janet_table_put(entry, janet_ckeywordv("source-map"), ------------------ | | 1843| 2.18k|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 2.18k|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 2.18k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32574| 2.18k| janet_wrap_tuple(janetc_make_sourcemap(c))); ------------------ | | 843| 2.18k|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 2.18k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32575| 2.18k| janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry)); ------------------ | | 849| 2.18k|#define janet_wrap_symbol(s) janet_nanbox_wrap_c((s), JANET_SYMBOL) | | ------------------ | | | | 828| 2.18k| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ janet_table_put(c->env, janet_wrap_symbol(sym), janet_wrap_table(entry)); ------------------ | | 846| 2.18k|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 2.18k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32576| 2.18k| refslot = janetc_cslot(janet_wrap_array(ref)); ------------------ | | 845| 2.18k|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 2.18k| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 2.18k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 2.18k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32577| 2.18k| janetc_emit_ssu(c, JOP_PUT_INDEX, refslot, s, 0, 0); 32578| 2.18k| return 1; 32579| 2.18k| } else { 32580| 757| int no_unused = reftab && reftab->count && janet_truthy(janet_table_get_keyword(reftab, "unused")); ------------------ | | 818| 757| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 757| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (32580:25): [True: 757, False: 0] | Branch (32580:35): [True: 0, False: 757] ------------------ 32581| 757| int no_shadow = reftab && reftab->count && janet_truthy(janet_table_get_keyword(reftab, "shadow")); ------------------ | | 818| 757| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 757| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (32581:25): [True: 757, False: 0] | Branch (32581:35): [True: 0, False: 757] ------------------ 32582| 757| uint32_t def_flags = 0; 32583| 757| if (no_unused) def_flags |= JANET_DEFFLAG_NO_UNUSED; ------------------ | | 1183| 0|#define JANET_DEFFLAG_NO_UNUSED 2 ------------------ | Branch (32583:13): [True: 0, False: 757] ------------------ 32584| 757| if (no_shadow) def_flags |= JANET_DEFFLAG_NO_SHADOWCHECK; ------------------ | | 1182| 0|#define JANET_DEFFLAG_NO_SHADOWCHECK 1 ------------------ | Branch (32584:13): [True: 0, False: 757] ------------------ 32585| 757| return namelocal(c, sym, JANET_SLOT_MUTABLE, s, def_flags); ------------------ | | 1040| 757|#define JANET_SLOT_MUTABLE 0x40000 ------------------ 32586| 757| } 32587| 2.94k|} janet.c:janetc_while: 32945| 753|static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv) { 32946| 753| JanetCompiler *c = opts.compiler; 32947| 753| JanetSlot cond; 32948| 753| JanetFopts subopts = janetc_fopts_default(c); 32949| 753| JanetScope tempscope; 32950| 753| int32_t labelwt, labeld, labeljt, labelc, i; 32951| 753| int infinite = 0; 32952| 753| int is_nil_form = 0; 32953| 753| int is_notnil_form = 0; 32954| 753| uint8_t ifjmp = JOP_JUMP_IF; 32955| 753| uint8_t ifnjmp = JOP_JUMP_IF_NOT; 32956| | 32957| 753| if (argn < 1) { ------------------ | Branch (32957:9): [True: 0, False: 753] ------------------ 32958| 0| janetc_cerror(c, "expected at least 1 argument to while"); 32959| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32960| 0| } 32961| | 32962| 753| labelwt = janet_v_count(c->buffer); ------------------ | | 759| 753|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 753|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 753|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 753, False: 0] | | ------------------ ------------------ 32963| | 32964| 753| janetc_scope(&tempscope, c, JANET_SCOPE_WHILE, "while"); ------------------ | | 1063| 753|#define JANET_SCOPE_WHILE 32 ------------------ 32965| | 32966| | /* Check for `(= nil _)` or `(not= nil _)` in condition, and if so, use the 32967| | * jmpnl or jmpnn instructions. This let's us implement `(each ...)` 32968| | * more efficiently. */ 32969| 753| Janet condform = argv[0]; 32970| 753| if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) { ------------------ | | 1017| 753|#define JANET_FUN_EQ 24 ------------------ | Branch (32970:9): [True: 0, False: 753] ------------------ 32971| 0| is_nil_form = 1; 32972| 0| ifjmp = JOP_JUMP_IF_NIL; 32973| 0| ifnjmp = JOP_JUMP_IF_NOT_NIL; 32974| 0| } 32975| 753| if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) { ------------------ | | 1018| 753|#define JANET_FUN_NEQ 25 ------------------ | Branch (32975:9): [True: 753, False: 0] ------------------ 32976| 753| is_notnil_form = 1; 32977| 753| ifjmp = JOP_JUMP_IF_NOT_NIL; 32978| 753| ifnjmp = JOP_JUMP_IF_NIL; 32979| 753| } 32980| | 32981| | /* Compile condition */ 32982| 753| cond = janetc_value(subopts, condform); 32983| | 32984| | /* Check for constant condition */ 32985| 753| if (cond.flags & JANET_SLOT_CONSTANT) { ------------------ | | 1038| 753|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (32985:9): [True: 0, False: 753] ------------------ 32986| | /* Loop never executes */ 32987| 0| int never_executes = is_nil_form ------------------ | Branch (32987:30): [True: 0, False: 0] ------------------ 32988| 0| ? !janet_checktype(cond.constant, JANET_NIL) ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32989| 0| : is_notnil_form ------------------ | Branch (32989:32): [True: 0, False: 0] ------------------ 32990| 0| ? janet_checktype(cond.constant, JANET_NIL) ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 0] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32991| 0| : !janet_truthy(cond.constant); ------------------ | | 818| 0| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 0, False: 0] | | ------------------ | | 819| 0| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 0] | | | Branch (819:47): [True: 0, False: 0] | | ------------------ ------------------ 32992| 0| if (never_executes) { ------------------ | Branch (32992:13): [True: 0, False: 0] ------------------ 32993| 0| janetc_popscope(c); 32994| 0| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 32995| 0| } 32996| | /* Infinite loop */ 32997| 0| infinite = 1; 32998| 0| } 32999| | 33000| | /* Infinite loop does not need to check condition */ 33001| 753| labelc = infinite ------------------ | Branch (33001:14): [True: 0, False: 753] ------------------ 33002| 753| ? 0 33003| 753| : janetc_emit_si(c, ifnjmp, cond, 0, 0); 33004| | 33005| | /* Compile body */ 33006| 5.51k| for (i = 1; i < argn; i++) { ------------------ | Branch (33006:17): [True: 4.76k, False: 753] ------------------ 33007| 4.76k| subopts.flags = JANET_FOPTS_DROP; ------------------ | | 1149| 4.76k|#define JANET_FOPTS_DROP 0x40000 ------------------ 33008| 4.76k| janetc_freeslot(c, janetc_value(subopts, argv[i])); 33009| 4.76k| } 33010| | 33011| | /* Check if closure created in while scope. If so, 33012| | * recompile in a function scope. */ 33013| 753| if (tempscope.flags & JANET_SCOPE_CLOSURE) { ------------------ | | 1062| 753|#define JANET_SCOPE_CLOSURE 16 ------------------ | Branch (33013:9): [True: 624, False: 129] ------------------ 33014| 624| subopts = janetc_fopts_default(c); 33015| 624| tempscope.flags |= JANET_SCOPE_UNUSED; ------------------ | | 1061| 624|#define JANET_SCOPE_UNUSED 8 ------------------ 33016| 624| janetc_popscope(c); 33017| 624| if (c->buffer) janet_v__cnt(c->buffer) = labelwt; ------------------ | | 766| 624|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 624|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (33017:13): [True: 624, False: 0] ------------------ 33018| 624| if (c->mapbuffer) janet_v__cnt(c->mapbuffer) = labelwt; ------------------ | | 766| 624|#define janet_v__cnt(v) janet_v__raw(v)[1] | | ------------------ | | | | 764| 624|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | ------------------ ------------------ | Branch (33018:13): [True: 624, False: 0] ------------------ 33019| | 33020| 624| janetc_scope(&tempscope, c, JANET_SCOPE_FUNCTION, "while-iife"); ------------------ | | 1058| 624|#define JANET_SCOPE_FUNCTION 1 ------------------ 33021| | 33022| | /* Recompile in the function scope */ 33023| 624| cond = janetc_value(subopts, condform); 33024| 624| if (!(cond.flags & JANET_SLOT_CONSTANT)) { ------------------ | | 1038| 624|#define JANET_SLOT_CONSTANT 0x10000 ------------------ | Branch (33024:13): [True: 622, False: 2] ------------------ 33025| | /* If not an infinite loop, return nil when condition false */ 33026| 622| janetc_emit_si(c, ifjmp, cond, 2, 0); 33027| 622| janetc_emit(c, JOP_RETURN_NIL); 33028| 622| } 33029| 4.56k| for (i = 1; i < argn; i++) { ------------------ | Branch (33029:21): [True: 3.94k, False: 624] ------------------ 33030| 3.94k| subopts.flags = JANET_FOPTS_DROP; ------------------ | | 1149| 3.94k|#define JANET_FOPTS_DROP 0x40000 ------------------ 33031| 3.94k| janetc_freeslot(c, janetc_value(subopts, argv[i])); 33032| 3.94k| } 33033| | /* But now add tail recursion */ 33034| 624| int32_t tempself = janetc_regalloc_temp(&tempscope.ra, JANETC_REGTEMP_0); 33035| 624| janetc_emit(c, JOP_LOAD_SELF | ((uint32_t) tempself << 8)); 33036| 624| janetc_emit(c, JOP_TAILCALL | ((uint32_t) tempself << 8)); 33037| 624| janetc_regalloc_freetemp(&c->scope->ra, tempself, JANETC_REGTEMP_0); 33038| | /* Compile function */ 33039| 624| JanetFuncDef *def = janetc_pop_funcdef(c, janet_cstring("while")); 33040| 624| janet_def_addflags(def); 33041| 624| int32_t defindex = janetc_addfuncdef(c, def); 33042| | /* Do basic optimization */ 33043| 624| if (!(c->scope->flags & JANET_SCOPE_UNUSED)) { ------------------ | | 1061| 624|#define JANET_SCOPE_UNUSED 8 ------------------ | Branch (33043:13): [True: 624, False: 0] ------------------ 33044| 624| janet_bytecode_optimize(def, c->optimize); 33045| 624| } 33046| | /* And then load the closure and call it. */ 33047| 624| int32_t cloreg = janetc_regalloc_temp(&c->scope->ra, JANETC_REGTEMP_0); 33048| 624| janetc_emit(c, JOP_CLOSURE | ((uint32_t) cloreg << 8) | ((uint32_t) defindex << 16)); 33049| 624| janetc_emit(c, JOP_CALL | ((uint32_t) cloreg << 8) | ((uint32_t) cloreg << 16)); 33050| 624| janetc_regalloc_freetemp(&c->scope->ra, cloreg, JANETC_REGTEMP_0); 33051| 624| c->scope->flags |= JANET_SCOPE_CLOSURE; ------------------ | | 1062| 624|#define JANET_SCOPE_CLOSURE 16 ------------------ 33052| 624| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 624|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 624| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 624|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 624|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33053| 624| } 33054| | 33055| | /* Compile jump to :whiletop */ 33056| 129| labeljt = janet_v_count(c->buffer); ------------------ | | 759| 129|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 129|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 129|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 129, False: 0] | | ------------------ ------------------ 33057| 129| janetc_emit(c, JOP_JUMP); 33058| | 33059| | /* Calculate jumps */ 33060| 129| labeld = janet_v_count(c->buffer); ------------------ | | 759| 129|#define janet_v_count(v) (((v) != NULL) ? janet_v__cnt(v) : 0) | | ------------------ | | | | 766| 129|#define janet_v__cnt(v) janet_v__raw(v)[1] | | | | ------------------ | | | | | | 764| 129|#define janet_v__raw(v) ((int32_t *)(v) - 2) | | | | ------------------ | | ------------------ | | | Branch (759:34): [True: 129, False: 0] | | ------------------ ------------------ 33061| 129| if (!infinite) { ------------------ | Branch (33061:9): [True: 129, False: 0] ------------------ 33062| 129| check_16bit_jump(c, labelc, labeld); 33063| 129| c->buffer[labelc] |= (uint32_t)(labeld - labelc) << 16; 33064| 129| } 33065| | 33066| 129| check_24bit_jump(c, labeljt, labelwt); 33067| 129| c->buffer[labeljt] |= (uint32_t)(labelwt - labeljt) << 8; 33068| | 33069| | /* Calculate breaks */ 33070| 4.59M| for (int32_t i = labelwt; i < labeld; i++) { ------------------ | Branch (33070:31): [True: 4.59M, False: 129] ------------------ 33071| 4.59M| if (c->buffer[i] == (0x80 | JOP_JUMP)) { ------------------ | Branch (33071:13): [True: 0, False: 4.59M] ------------------ 33072| 0| check_24bit_jump(c, i, labeld); 33073| 0| c->buffer[i] = JOP_JUMP | ((uint32_t)(labeld - i) << 8); 33074| 0| } 33075| 4.59M| } 33076| | 33077| | /* Pop scope and return nil slot */ 33078| 129| janetc_popscope(c); 33079| | 33080| 129| return janetc_cslot(janet_wrap_nil()); ------------------ | | 831| 129|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 129| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 129|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 129|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 33081| 753|} janet.c:bignat_zero: 34185| 1.52M|static void bignat_zero(struct BigNat *x) { 34186| 1.52M| x->first_digit = 0; 34187| 1.52M| x->n = 0; 34188| 1.52M| x->cap = 0; 34189| | x->digits = NULL; 34190| 1.52M|} janet.c:bignat_muladd: 34217| 800k|static void bignat_muladd(struct BigNat *mant, uint32_t factor, uint32_t term) { 34218| 800k| int32_t i; 34219| 800k| uint64_t carry = ((uint64_t) mant->first_digit) * factor + term; 34220| 800k| mant->first_digit = carry % BIGNAT_BASE; ------------------ | |34174| 800k|#define BIGNAT_BASE 0x80000000U ------------------ 34221| 800k| carry /= BIGNAT_BASE; ------------------ | |34174| 800k|#define BIGNAT_BASE 0x80000000U ------------------ 34222| 93.2M| for (i = 0; i < mant->n; i++) { ------------------ | Branch (34222:17): [True: 92.4M, False: 800k] ------------------ 34223| 92.4M| carry += ((uint64_t) mant->digits[i]) * factor; 34224| 92.4M| mant->digits[i] = carry % BIGNAT_BASE; ------------------ | |34174| 92.4M|#define BIGNAT_BASE 0x80000000U ------------------ 34225| 92.4M| carry /= BIGNAT_BASE; ------------------ | |34174| 92.4M|#define BIGNAT_BASE 0x80000000U ------------------ 34226| 92.4M| } 34227| 800k| if (carry) bignat_append(mant, (uint32_t) carry); ------------------ | Branch (34227:9): [True: 10.0k, False: 790k] ------------------ 34228| 800k|} janet.c:bignat_append: 34210| 10.0k|static void bignat_append(struct BigNat *mant, uint32_t dig) { 34211| 10.0k| bignat_extra(mant, 1)[0] = dig; 34212| 10.0k|} janet.c:bignat_extra: 34193| 10.4k|static uint32_t *bignat_extra(struct BigNat *mant, int32_t n) { 34194| 10.4k| int32_t oldn = mant->n; 34195| 10.4k| int32_t newn = oldn + n; 34196| 10.4k| if (mant->cap < newn) { ------------------ | Branch (34196:9): [True: 4.38k, False: 6.09k] ------------------ 34197| 4.38k| int32_t newcap = 2 * newn; 34198| 4.38k| uint32_t *mem = janet_realloc(mant->digits, (size_t) newcap * sizeof(uint32_t)); ------------------ | | 2409| 4.38k|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 34199| 4.38k| if (NULL == mem) { ------------------ | Branch (34199:13): [True: 0, False: 4.38k] ------------------ 34200| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 34201| 0| } 34202| 4.38k| mant->cap = newcap; 34203| 4.38k| mant->digits = mem; 34204| 4.38k| } 34205| 10.4k| mant->n = newn; 34206| 10.4k| return mant->digits + oldn; 34207| 10.4k|} janet.c:convert: 34313| 805k| int32_t exponent) { 34314| | 34315| 805k| int32_t exponent2 = 0; 34316| | 34317| | /* Approximate exponent in base 2 of mant and exponent. This should get us a good estimate of the final size of the 34318| | * number, within * 2^32 or so. */ 34319| 805k| int64_t mant_exp2_approx = mant->n * 32 + 16; 34320| 805k| int64_t exp_exp2_approx = (int64_t)(floor(log2(base) * exponent)); 34321| 805k| int64_t exp2_approx = mant_exp2_approx + exp_exp2_approx; 34322| | 34323| | /* Short circuit zero, huge, and small numbers. We use the exponent range of valid IEEE754 doubles (-1022, 1023) 34324| | * with a healthy buffer to allow for inaccuracies in the approximation and denormailzed numbers. */ 34325| 805k| if (mant->n == 0 && mant->first_digit == 0) ------------------ | Branch (34325:9): [True: 802k, False: 2.15k] | Branch (34325:25): [True: 172k, False: 630k] ------------------ 34326| 172k| return negative ? -0.0 : 0.0; ------------------ | Branch (34326:16): [True: 1, False: 172k] ------------------ 34327| 632k| if (exp2_approx > 1176) ------------------ | Branch (34327:9): [True: 517, False: 632k] ------------------ 34328| 517| return negative ? -INFINITY : INFINITY; ------------------ | Branch (34328:16): [True: 155, False: 362] ------------------ 34329| 632k| if (exp2_approx < -1175) ------------------ | Branch (34329:9): [True: 0, False: 632k] ------------------ 34330| 0| return negative ? -0.0 : 0.0; ------------------ | Branch (34330:16): [True: 0, False: 0] ------------------ 34331| | 34332| | /* Final value is X = mant * base ^ exponent * 2 ^ exponent2 34333| | * Get exponent to zero while holding X constant. */ 34334| | 34335| | /* Positive exponents are simple */ 34336| 636k| for (; exponent > 3; exponent -= 4) bignat_muladd(mant, base * base * base * base, 0); ------------------ | Branch (34336:12): [True: 4.19k, False: 632k] ------------------ 34337| 632k| for (; exponent > 1; exponent -= 2) bignat_muladd(mant, base * base, 0); ------------------ | Branch (34337:12): [True: 137, False: 632k] ------------------ 34338| 633k| for (; exponent > 0; exponent -= 1) bignat_muladd(mant, base, 0); ------------------ | Branch (34338:12): [True: 1.49k, False: 632k] ------------------ 34339| | 34340| | /* Negative exponents are tricky - we don't want to loose bits 34341| | * from integer division, so we need to premultiply. */ 34342| 632k| if (exponent < 0) { ------------------ | Branch (34342:9): [True: 378, False: 632k] ------------------ 34343| 378| int32_t shamt = 5 - exponent / 4; 34344| 378| bignat_lshift_n(mant, shamt); 34345| 378| exponent2 -= shamt * BIGNAT_NBIT; ------------------ | |34173| 378|#define BIGNAT_NBIT 31 ------------------ 34346| 762| for (; exponent < -3; exponent += 4) bignat_div(mant, base * base * base * base); ------------------ | Branch (34346:16): [True: 384, False: 378] ------------------ 34347| 537| for (; exponent < -1; exponent += 2) bignat_div(mant, base * base); ------------------ | Branch (34347:16): [True: 159, False: 378] ------------------ 34348| 689| for (; exponent < 0; exponent += 1) bignat_div(mant, base); ------------------ | Branch (34348:16): [True: 311, False: 378] ------------------ 34349| 378| } 34350| | 34351| 632k| return negative ------------------ | Branch (34351:12): [True: 2.66k, False: 629k] ------------------ 34352| 632k| ? -bignat_extract(mant, exponent2) 34353| 632k| : bignat_extract(mant, exponent2); 34354| 632k|} janet.c:bignat_lshift_n: 34249| 378|static void bignat_lshift_n(struct BigNat *mant, int n) { 34250| 378| if (!n) return; ------------------ | Branch (34250:9): [True: 0, False: 378] ------------------ 34251| 378| int32_t oldn = mant->n; 34252| 378| bignat_extra(mant, n); 34253| 378| memmove(mant->digits + n, mant->digits, sizeof(uint32_t) * oldn); 34254| 378| memset(mant->digits, 0, sizeof(uint32_t) * (n - 1)); 34255| 378| mant->digits[n - 1] = mant->first_digit; 34256| 378| mant->first_digit = 0; 34257| 378|} janet.c:bignat_div: 34231| 854|static void bignat_div(struct BigNat *mant, uint32_t divisor) { 34232| 854| int32_t i; 34233| 854| uint32_t quotient, remainder; 34234| 854| uint64_t dividend; 34235| 854| remainder = 0, quotient = 0; 34236| 7.18k| for (i = mant->n - 1; i >= 0; i--) { ------------------ | Branch (34236:27): [True: 6.32k, False: 854] ------------------ 34237| 6.32k| dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->digits[i]; ------------------ | |34174| 6.32k|#define BIGNAT_BASE 0x80000000U ------------------ 34238| 6.32k| if (i < mant->n - 1) mant->digits[i + 1] = quotient; ------------------ | Branch (34238:13): [True: 5.47k, False: 854] ------------------ 34239| 6.32k| quotient = (uint32_t)(dividend / divisor); 34240| 6.32k| remainder = (uint32_t)(dividend % divisor); 34241| 6.32k| mant->digits[i] = remainder; 34242| 6.32k| } 34243| 854| dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->first_digit; ------------------ | |34174| 854|#define BIGNAT_BASE 0x80000000U ------------------ 34244| 854| if (mant->n && mant->digits[mant->n - 1] == 0) mant->n--; ------------------ | Branch (34244:9): [True: 854, False: 0] | Branch (34244:20): [True: 449, False: 405] ------------------ 34245| 854| mant->first_digit = (uint32_t)(dividend / divisor); 34246| 854|} janet.c:bignat_extract: 34274| 632k|static double bignat_extract(struct BigNat *mant, int32_t exponent2) { 34275| 632k| uint64_t top53; 34276| 632k| int32_t n = mant->n; 34277| | /* Get most significant 53 bits from mant. Bit 52 (0 indexed) should 34278| | * always be 1. This is essentially a large right shift on mant.*/ 34279| 632k| if (n) { ------------------ | Branch (34279:9): [True: 3.83k, False: 628k] ------------------ 34280| | /* Two or more digits */ 34281| 3.83k| uint64_t d1 = mant->digits[n - 1]; /* MSD (non-zero) */ 34282| 3.83k| uint64_t d2 = (n == 1) ? mant->first_digit : mant->digits[n - 2]; ------------------ | Branch (34282:23): [True: 2.49k, False: 1.34k] ------------------ 34283| 3.83k| uint64_t d3 = (n > 2) ? mant->digits[n - 3] : (n == 2) ? mant->first_digit : 0; ------------------ | Branch (34283:23): [True: 570, False: 3.26k] | Branch (34283:55): [True: 775, False: 2.49k] ------------------ 34284| 3.83k| int lz = clz((uint32_t) d1); ------------------ | |34260| 3.83k|#define clz(x) __builtin_clz(x) ------------------ 34285| 3.83k| int nbits = 32 - lz; 34286| | /* First get 54 bits */ 34287| 3.83k| top53 = (d2 << (54 - BIGNAT_NBIT)) + (d3 >> (2 * BIGNAT_NBIT - 54)); ------------------ | |34173| 3.83k|#define BIGNAT_NBIT 31 ------------------ top53 = (d2 << (54 - BIGNAT_NBIT)) + (d3 >> (2 * BIGNAT_NBIT - 54)); ------------------ | |34173| 3.83k|#define BIGNAT_NBIT 31 ------------------ 34288| 3.83k| top53 >>= nbits; 34289| 3.83k| top53 |= (d1 << (54 - nbits)); 34290| | /* Rounding based on lowest bit of 54 */ 34291| 3.83k| if (top53 & 1) top53++; ------------------ | Branch (34291:13): [True: 1.49k, False: 2.34k] ------------------ 34292| 3.83k| top53 >>= 1; 34293| 3.83k| if (top53 > 0x1FffffFFFFffffUL) { ------------------ | Branch (34293:13): [True: 511, False: 3.32k] ------------------ 34294| 511| top53 >>= 1; 34295| 511| exponent2++; 34296| 511| } 34297| | /* Correct exponent - to correct for large right shift to mantissa. */ 34298| 3.83k| exponent2 += (nbits - 53) + BIGNAT_NBIT * n; ------------------ | |34173| 3.83k|#define BIGNAT_NBIT 31 ------------------ 34299| 628k| } else { 34300| | /* One digit */ 34301| 628k| top53 = mant->first_digit; 34302| 628k| } 34303| 632k| return ldexp((double)top53, exponent2); 34304| 632k|} janet.c:scan_uint64: 34514| 6.11k| int *neg) { 34515| 6.11k| const uint8_t *end = str + len; 34516| 6.11k| int seenadigit = 0; 34517| 6.11k| int base = 10; 34518| 6.11k| *neg = 0; 34519| 6.11k| *out = 0; 34520| 6.11k| uint64_t accum = 0; 34521| 6.11k| if (len > JANET_NUMBER_LENGTH_RIDICULOUS) return 0; ------------------ | |34158| 6.11k|#define JANET_NUMBER_LENGTH_RIDICULOUS 0xFFFF ------------------ | Branch (34521:9): [True: 1, False: 6.11k] ------------------ 34522| | /* Get sign */ 34523| 6.11k| if (str >= end) return 0; ------------------ | Branch (34523:9): [True: 0, False: 6.11k] ------------------ 34524| 6.11k| if (*str == '-') { ------------------ | Branch (34524:9): [True: 621, False: 5.49k] ------------------ 34525| 621| *neg = 1; 34526| 621| str++; 34527| 5.49k| } else if (*str == '+') { ------------------ | Branch (34527:16): [True: 3.18k, False: 2.31k] ------------------ 34528| 3.18k| str++; 34529| 3.18k| } 34530| | /* Check for leading 0x or digit digit r */ 34531| 6.11k| if (str + 1 < end && str[0] == '0' && str[1] == 'x') { ------------------ | Branch (34531:9): [True: 3.71k, False: 2.40k] | Branch (34531:26): [True: 1.54k, False: 2.17k] | Branch (34531:43): [True: 198, False: 1.34k] ------------------ 34532| 198| base = 16; 34533| 198| str += 2; 34534| 5.91k| } else if (str + 1 < end && ------------------ | Branch (34534:16): [True: 3.51k, False: 2.40k] ------------------ 34535| 3.51k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34535:16): [True: 3.51k, False: 0] | Branch (34535:33): [True: 3.48k, False: 31] ------------------ 34536| 3.48k| str[1] == 'r') { ------------------ | Branch (34536:16): [True: 0, False: 3.48k] ------------------ 34537| 0| base = str[0] - '0'; 34538| 0| str += 2; 34539| 5.91k| } else if (str + 2 < end && ------------------ | Branch (34539:16): [True: 3.08k, False: 2.83k] ------------------ 34540| 3.08k| str[0] >= '0' && str[0] <= '9' && ------------------ | Branch (34540:16): [True: 3.08k, False: 0] | Branch (34540:33): [True: 3.05k, False: 31] ------------------ 34541| 3.05k| str[1] >= '0' && str[1] <= '9' && ------------------ | Branch (34541:16): [True: 3.05k, False: 0] | Branch (34541:33): [True: 2.60k, False: 452] ------------------ 34542| 2.60k| str[2] == 'r') { ------------------ | Branch (34542:16): [True: 848, False: 1.75k] ------------------ 34543| 848| base = 10 * (str[0] - '0') + (str[1] - '0'); 34544| 848| if (base < 2 || base > 36) return 0; ------------------ | Branch (34544:13): [True: 227, False: 621] | Branch (34544:25): [True: 0, False: 621] ------------------ 34545| 621| str += 3; 34546| 621| } 34547| | 34548| | /* Skip leading zeros */ 34549| 10.5k| while (str < end && *str == '0') { ------------------ | Branch (34549:12): [True: 8.24k, False: 2.26k] | Branch (34549:25): [True: 4.62k, False: 3.62k] ------------------ 34550| 4.62k| seenadigit = 1; 34551| 4.62k| str++; 34552| 4.62k| } 34553| | /* Parse significant digits */ 34554| 19.4k| while (str < end) { ------------------ | Branch (34554:12): [True: 14.3k, False: 5.03k] ------------------ 34555| 14.3k| if (*str == '_') { ------------------ | Branch (34555:13): [True: 5, False: 14.3k] ------------------ 34556| 5| if (!seenadigit) return 0; ------------------ | Branch (34556:17): [True: 0, False: 5] ------------------ 34557| 14.3k| } else { 34558| 14.3k| int digit = digit_lookup[*str & 0x7F]; 34559| 14.3k| if (*str > 127 || digit >= base) return 0; ------------------ | Branch (34559:17): [True: 0, False: 14.3k] | Branch (34559:31): [True: 526, False: 13.8k] ------------------ 34560| 13.8k| if (accum > (UINT64_MAX - digit) / base) return 0; ------------------ | Branch (34560:17): [True: 334, False: 13.5k] ------------------ 34561| 13.5k| accum = accum * base + digit; 34562| 13.5k| seenadigit = 1; 34563| 13.5k| } 34564| 13.5k| str++; 34565| 13.5k| } 34566| | 34567| 5.03k| if (!seenadigit) return 0; ------------------ | Branch (34567:9): [True: 148, False: 4.88k] ------------------ 34568| 4.88k| *out = accum; 34569| 4.88k| return 1; 34570| 5.03k|} janet.c:janet_dict_find: 433| 8.51M|static inline const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) { 434| 8.51M| int32_t hash; 435| 8.51M| if (janet_checktype(key, JANET_KEYWORD) || janet_checktype(key, JANET_SYMBOL)) { ------------------ | | 806| 17.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.23M, False: 4.27M] | | | Branch (806:6): [Folded, False: 8.51M] | | ------------------ | | 807| 17.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 17.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 8.51M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 8.51M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 8.51M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 8.51M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(key, JANET_KEYWORD) || janet_checktype(key, JANET_SYMBOL)) { ------------------ | | 806| 4.27M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2.97M, False: 1.30M] | | | Branch (806:6): [Folded, False: 4.27M] | | ------------------ | | 807| 4.27M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4.27M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 4.27M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 4.27M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 4.27M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 4.27M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 436| 7.21M| hash = janet_string_hash(janet_unwrap_string(key)); ------------------ | | 1814| 7.21M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | ------------------ | | | | 1812| 7.21M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | ------------------ ------------------ 437| 7.21M| } else if (janet_checktypes(key, JANET_TFLAG_NIL | JANET_TFLAG_STRING | JANET_TFLAG_TUPLE | JANET_TFLAG_STRUCT | JANET_TFLAG_ABSTRACT) || ------------------ | | 969| 2.60M|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | ------------------ | | | | 795| 1.30M| (isnan((x).number) \ | | | | 796| 1.30M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | 797| 1.30M| : JANET_NUMBER) | | ------------------ | | | Branch (969:34): [True: 671k, False: 628k] | | ------------------ ------------------ | Branch (437:16): [True: 1.28M, False: 12.6k] ------------------ 438| 672k| (janet_checktype(key, JANET_NUMBER) && janet_unwrap_number(key) == 0)) { ------------------ | | 806| 1.25M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 12.6k, False: 616k] | | | Branch (806:6): [True: 628k, Folded] | | ------------------ | | 807| 1.25M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 628k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 12.6k, False: 616k] | | | | | Branch (803:28): [True: 0, False: 616k] | | | | ------------------ | | ------------------ | | 808| 1.25M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ (janet_checktype(key, JANET_NUMBER) && janet_unwrap_number(key) == 0)) { ------------------ | | 839| 12.6k|#define janet_unwrap_number(x) ((x).number) ------------------ | Branch (438:55): [True: 102, False: 12.5k] ------------------ 439| 672k| return janet_dict_find_deep(buckets, cap, key); 440| 672k| } else { 441| 628k| hash = janet_hash(key); 442| 628k| } 443| 7.84M| uint32_t mask = (uint32_t) cap - 1; 444| 7.84M| uint32_t i = (uint32_t) hash & mask; 445| 7.84M| const JanetKV *first_bucket = NULL; 446| 64.9M| for (int32_t n = 0; n < cap; n++, i = (i + 1) & mask) { ------------------ | Branch (446:25): [True: 64.9M, False: 0] ------------------ 447| 64.9M| const JanetKV *kv = buckets + i; 448| 64.9M| if (janet_bitwise_same(kv->key, key)) return kv; ------------------ | | 401| 64.9M|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 64.9M|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 64.9M|#define janet_u64(x) ((x).u64) | | ------------------ | | | Branch (401:34): [True: 2.62M, False: 62.3M] | | ------------------ ------------------ 449| 62.3M| if (janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 62.3M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 41.7M, False: 20.6M] | | | Branch (806:6): [Folded, False: 62.3M] | | ------------------ | | 807| 62.3M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 62.3M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 62.3M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 62.3M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 62.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 62.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 450| 41.7M| if (janet_checktype(kv->value, JANET_NIL)) return kv; ------------------ | | 806| 41.7M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 5.21M, False: 36.4M] | | | Branch (806:6): [Folded, False: 41.7M] | | ------------------ | | 807| 41.7M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 41.7M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 41.7M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 41.7M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 41.7M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 41.7M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 451| 36.4M| if (NULL == first_bucket) first_bucket = kv; ------------------ | Branch (451:17): [True: 448k, False: 36.0M] ------------------ 452| 36.4M| } 453| 62.3M| } 454| 0| return first_bucket; 455| 7.84M|} janet.c:janet_symcache_findmem: 35042| 28.5M| int *success) { 35043| 28.5M| uint32_t bounds[4]; 35044| 28.5M| uint32_t i, j, index; 35045| 28.5M| const uint8_t **firstEmpty = NULL; 35046| | 35047| | /* We will search two ranges - index to the end, 35048| | * and 0 to the index. */ 35049| 28.5M| index = (uint32_t)hash & (janet_vm.cache_capacity - 1); 35050| 28.5M| bounds[0] = index; 35051| 28.5M| bounds[1] = janet_vm.cache_capacity; 35052| 28.5M| bounds[2] = 0; 35053| 28.5M| bounds[3] = index; 35054| 28.5M| for (j = 0; j < 4; j += 2) ------------------ | Branch (35054:17): [True: 28.5M, False: 0] ------------------ 35055| 42.4M| for (i = bounds[j]; i < bounds[j + 1]; ++i) { ------------------ | Branch (35055:29): [True: 42.4M, False: 1.33k] ------------------ 35056| 42.4M| const uint8_t *test = janet_vm.cache[i]; 35057| | /* Check empty spots */ 35058| 42.4M| if (NULL == test) { ------------------ | Branch (35058:17): [True: 2.61M, False: 39.8M] ------------------ 35059| 2.61M| if (NULL == firstEmpty) ------------------ | Branch (35059:21): [True: 2.61M, False: 0] ------------------ 35060| 2.61M| firstEmpty = janet_vm.cache + i; 35061| 2.61M| goto notfound; 35062| 2.61M| } 35063| | /* Check for marked deleted */ 35064| 39.8M| if (JANET_SYMCACHE_DELETED == test) { ------------------ | Branch (35064:17): [True: 791, False: 39.8M] ------------------ 35065| 791| if (firstEmpty == NULL) ------------------ | Branch (35065:21): [True: 422, False: 369] ------------------ 35066| 422| firstEmpty = janet_vm.cache + i; 35067| 791| continue; 35068| 791| } 35069| 39.8M| if (janet_string_equalconst(test, str, len, hash)) { ------------------ | Branch (35069:17): [True: 25.9M, False: 13.8M] ------------------ 35070| | /* Replace first deleted */ 35071| 25.9M| *success = 1; 35072| 25.9M| if (firstEmpty != NULL) { ------------------ | Branch (35072:21): [True: 422, False: 25.9M] ------------------ 35073| 422| *firstEmpty = test; 35074| 422| janet_vm.cache[i] = JANET_SYMCACHE_DELETED; 35075| 422| return firstEmpty; 35076| 422| } 35077| 25.9M| return janet_vm.cache + i; 35078| 25.9M| } 35079| 39.8M| } 35080| 2.61M|notfound: 35081| 2.61M| *success = 0; 35082| 2.61M| janet_assert(firstEmpty != NULL, "symcache failed to get memory"); ------------------ | | 389| 2.61M|#define janet_assert(c, m) do { \ | | 390| 2.61M| if (!(c)) JANET_EXIT((m)); \ | | ------------------ | | | | 378| 0|#define JANET_EXIT(m) do { \ | | | | 379| 0| fprintf(stderr, "janet abort at %s:%d: %s\n",\ | | | | 380| 0| __FILE__,\ | | | | 381| 0| __LINE__,\ | | | | 382| 0| (m));\ | | | | 383| 0| abort();\ | | | | 384| 0|} while (0) | | | | ------------------ | | | | | Branch (384:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (390:9): [True: 0, False: 2.61M] | | ------------------ | | 391| 2.61M|} while (0) | | ------------------ | | | Branch (391:10): [Folded, False: 2.61M] | | ------------------ ------------------ 35083| 2.61M| return firstEmpty; 35084| 2.61M|} janet.c:janet_symcache_put: 35120| 1.13M|static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) { 35121| 1.13M| if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) { ------------------ | Branch (35121:9): [True: 642, False: 1.12M] ------------------ 35122| 642| int status; 35123| 642| janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1))); 35124| 642| bucket = janet_symcache_find(x, &status); ------------------ | |35087| 642| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 642|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 642|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1814| 642|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 642|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35125| 642| } 35126| | /* Add x to the cache */ 35127| 1.13M| janet_vm.cache_count++; 35128| 1.13M| *bucket = x; 35129| 1.13M|} janet.c:janet_cache_resize: 35090| 642|static void janet_cache_resize(uint32_t newCapacity) { 35091| 642| uint32_t i, oldCapacity; 35092| 642| const uint8_t **oldCache = janet_vm.cache; 35093| 642| const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *)); ------------------ | | 2412| 642|#define janet_calloc(X, Y) calloc((X), (Y)) ------------------ 35094| 642| if (newCache == NULL) { ------------------ | Branch (35094:9): [True: 0, False: 642] ------------------ 35095| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35096| 0| } 35097| 642| oldCapacity = janet_vm.cache_capacity; 35098| 642| janet_vm.cache = newCache; 35099| 642| janet_vm.cache_capacity = newCapacity; 35100| 642| janet_vm.cache_deleted = 0; 35101| | /* Add all of the old cache entries back */ 35102| 2.96M| for (i = 0; i < oldCapacity; ++i) { ------------------ | Branch (35102:17): [True: 2.96M, False: 642] ------------------ 35103| 2.96M| int status; 35104| 2.96M| const uint8_t **bucket; 35105| 2.96M| const uint8_t *x = oldCache[i]; 35106| 2.96M| if (x != NULL && x != JANET_SYMCACHE_DELETED) { ------------------ | Branch (35106:13): [True: 1.48M, False: 1.48M] | Branch (35106:26): [True: 1.48M, False: 0] ------------------ 35107| 1.48M| bucket = janet_symcache_find(x, &status); ------------------ | |35087| 1.48M| janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1813| 1.48M|#define janet_string_length(s) (janet_string_head(s)->length) | | | | ------------------ | | | | | | 1812| 1.48M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ | | janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success)) | | ------------------ | | | | 1814| 1.48M|#define janet_string_hash(s) (janet_string_head(s)->hash) | | | | ------------------ | | | | | | 1812| 1.48M|#define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data))) | | | | ------------------ | | ------------------ ------------------ 35108| 1.48M| if (status || bucket == NULL) { ------------------ | Branch (35108:17): [True: 0, False: 1.48M] | Branch (35108:27): [True: 0, False: 1.48M] ------------------ 35109| | /* there was a problem with the algorithm. */ 35110| 0| break; 35111| 0| } 35112| 1.48M| *bucket = x; 35113| 1.48M| } 35114| 2.96M| } 35115| | /* Free the old cache */ 35116| 642| janet_free((void *)oldCache); ------------------ | | 2415| 642|#define janet_free(X) free((X)) ------------------ 35117| 642|} janet.c:inc_gensym: 35166| 645k|static void inc_gensym(void) { 35167| 655k| for (int i = sizeof(janet_vm.gensym_counter) - 2; i; i--) { ------------------ | Branch (35167:55): [True: 655k, False: 0] ------------------ 35168| 655k| if (janet_vm.gensym_counter[i] == '9') { ------------------ | Branch (35168:13): [True: 10.6k, False: 645k] ------------------ 35169| 10.6k| janet_vm.gensym_counter[i] = 'a'; 35170| 10.6k| break; 35171| 645k| } else if (janet_vm.gensym_counter[i] == 'z') { ------------------ | Branch (35171:20): [True: 10.5k, False: 634k] ------------------ 35172| 10.5k| janet_vm.gensym_counter[i] = 'A'; 35173| 10.5k| break; 35174| 634k| } else if (janet_vm.gensym_counter[i] == 'Z') { ------------------ | Branch (35174:20): [True: 10.4k, False: 624k] ------------------ 35175| 10.4k| janet_vm.gensym_counter[i] = '0'; 35176| 624k| } else { 35177| 624k| janet_vm.gensym_counter[i]++; 35178| 624k| break; 35179| 624k| } 35180| 655k| } 35181| 645k|} janet.c:janet_table_init_impl: 35261| 352k|static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) { 35262| 352k| JanetKV *data; 35263| 352k| capacity = janet_tablen(capacity); 35264| 352k| if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK; ------------------ | |35247| 54.2k|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ | Branch (35264:9): [True: 54.2k, False: 298k] ------------------ 35265| 352k| if (capacity) { ------------------ | Branch (35265:9): [True: 352k, False: 0] ------------------ 35266| 352k| if (stackalloc) { ------------------ | Branch (35266:13): [True: 54.2k, False: 298k] ------------------ 35267| 54.2k| data = janet_memalloc_empty_local(capacity); 35268| 298k| } else { 35269| 298k| data = (JanetKV *) janet_memalloc_empty(capacity); 35270| 298k| if (NULL == data) { ------------------ | Branch (35270:17): [True: 0, False: 298k] ------------------ 35271| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35272| 0| } 35273| 298k| } 35274| 352k| table->data = data; 35275| 352k| table->capacity = capacity; 35276| 352k| } else { 35277| 0| table->data = NULL; 35278| 0| table->capacity = 0; 35279| 0| } 35280| 352k| table->count = 0; 35281| 352k| table->deleted = 0; 35282| | table->proto = NULL; 35283| 352k| return table; 35284| 352k|} janet.c:janet_memalloc_empty_local: 35249| 61.2k|static void *janet_memalloc_empty_local(int32_t count) { 35250| 61.2k| int32_t i; 35251| 61.2k| void *mem = janet_smalloc((size_t) count * sizeof(JanetKV)); 35252| 61.2k| JanetKV *mmem = (JanetKV *)mem; 35253| 1.82M| for (i = 0; i < count; i++) { ------------------ | Branch (35253:17): [True: 1.76M, False: 61.2k] ------------------ 35254| 1.76M| JanetKV *kv = mmem + i; 35255| 1.76M| kv->key = janet_wrap_nil(); ------------------ | | 831| 1.76M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.76M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.76M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.76M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35256| 1.76M| kv->value = janet_wrap_nil(); ------------------ | | 831| 1.76M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.76M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.76M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.76M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 35257| 1.76M| } 35258| 61.2k| return mem; 35259| 61.2k|} janet.c:janet_table_rehash: 35334| 164k|static void janet_table_rehash(JanetTable *t, int32_t size) { 35335| 164k| JanetKV *olddata = t->data; 35336| 164k| JanetKV *newdata; 35337| 164k| int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK; ------------------ | |35247| 164k|#define JANET_TABLE_FLAG_STACK 0x10000 ------------------ 35338| 164k| if (islocal) { ------------------ | Branch (35338:9): [True: 6.94k, False: 157k] ------------------ 35339| 6.94k| newdata = (JanetKV *) janet_memalloc_empty_local(size); 35340| 157k| } else { 35341| 157k| newdata = (JanetKV *) janet_memalloc_empty(size); 35342| 157k| if (NULL == newdata) { ------------------ | Branch (35342:13): [True: 0, False: 157k] ------------------ 35343| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 35344| 0| } 35345| 157k| } 35346| 164k| int32_t oldcapacity = t->capacity; 35347| 164k| t->data = newdata; 35348| 164k| t->capacity = size; 35349| 164k| t->deleted = 0; 35350| 3.17M| for (int32_t i = 0; i < oldcapacity; i++) { ------------------ | Branch (35350:25): [True: 3.01M, False: 164k] ------------------ 35351| 3.01M| JanetKV *kv = olddata + i; 35352| 3.01M| if (!janet_checktype(kv->key, JANET_NIL)) { ------------------ | | 806| 3.01M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 3.01M] | | ------------------ | | 807| 3.01M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.01M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.01M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.01M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.01M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.01M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (35352:13): [True: 1.36M, False: 1.65M] ------------------ 35353| 1.36M| JanetKV *newkv = janet_table_find(t, kv->key); 35354| 1.36M| *newkv = *kv; 35355| 1.36M| } 35356| 3.01M| } 35357| 164k| if (islocal) { ------------------ | Branch (35357:9): [True: 6.94k, False: 157k] ------------------ 35358| 6.94k| janet_sfree(olddata); 35359| 157k| } else { 35360| 157k| janet_free(olddata); ------------------ | | 2415| 157k|#define janet_free(X) free((X)) ------------------ 35361| 157k| } 35362| 164k|} janet.c:janet_check_pointer_align: 36423| 95.3k|static void janet_check_pointer_align(void *p) { 36424| 95.3k| (void) p; 36425| |#if defined(JANET_NANBOX_64) && JANET_NANBOX_64_POINTER_SHIFT != 0 36426| | union { 36427| | void *p; 36428| | uintptr_t u; 36429| | } un; 36430| | un.p = p; 36431| | janet_assert(!(un.u & (uintptr_t)((1 << JANET_NANBOX_64_POINTER_SHIFT) - 1)), 36432| | "unaligned pointer wrap - cfunction pointers and abstract types must be aligned with this nanboxing configuration."); 36433| |#endif 36434| 95.3k|} janet.c:janet_equals_containers: 37334| 434k|static int janet_equals_containers(Janet x, Janet y) { 37335| 434k| janet_vm.traversal = janet_vm.traversal_base; 37336| 526k| do { 37337| 526k| if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 526k| (isnan((x).number) \ | | 796| 526k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 526k| : JANET_NUMBER) ------------------ if (janet_type(x) != janet_type(y)) return 0; ------------------ | | 795| 526k| (isnan((x).number) \ | | 796| 526k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 526k| : JANET_NUMBER) ------------------ | Branch (37337:13): [True: 526k, False: 0] | Branch (37337:13): [True: 0, False: 526k] | Branch (37337:30): [True: 526k, False: 0] ------------------ 37338| 526k| switch (janet_type(x)) { ------------------ | | 795| 526k| (isnan((x).number) \ | | 796| 526k| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 526k| : JANET_NUMBER) ------------------ | Branch (37338:17): [True: 526k, False: 0] ------------------ 37339| 57.7k| default: ------------------ | Branch (37339:13): [True: 57.7k, False: 468k] ------------------ 37340| 57.7k| if (!janet_equals_leaf(x, y)) return 0; ------------------ | Branch (37340:21): [True: 0, False: 57.7k] ------------------ 37341| 57.7k| break; 37342| 468k| case JANET_TUPLE: { ------------------ | Branch (37342:13): [True: 468k, False: 58.0k] ------------------ 37343| 468k| const Janet *t1 = janet_unwrap_tuple(x); ------------------ | | 858| 468k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37344| 468k| const Janet *t2 = janet_unwrap_tuple(y); ------------------ | | 858| 468k|#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x)) ------------------ 37345| 468k| if (t1 == t2) break; ------------------ | Branch (37345:21): [True: 0, False: 468k] ------------------ 37346| 468k| if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1798| 468k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1806| 468k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 468k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (JANET_TUPLE_FLAG_BRACKETCTOR & (janet_tuple_flag(t1) ^ janet_tuple_flag(t2))) return 0; ------------------ | | 1806| 468k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 468k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37346:21): [True: 4.30k, False: 464k] ------------------ 37347| 464k| if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1803| 464k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 464k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_hash(t1) != janet_tuple_hash(t2)) return 0; ------------------ | | 1803| 464k|#define janet_tuple_hash(t) (janet_tuple_head(t)->hash) | | ------------------ | | | | 1800| 464k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37347:21): [True: 418k, False: 45.8k] ------------------ 37348| 45.8k| if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1802| 45.8k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 45.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ if (janet_tuple_length(t1) != janet_tuple_length(t2)) return 0; ------------------ | | 1802| 45.8k|#define janet_tuple_length(t) (janet_tuple_head(t)->length) | | ------------------ | | | | 1800| 45.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ | Branch (37348:21): [True: 0, False: 45.8k] ------------------ 37349| 45.8k| push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1800| 45.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ push_traversal_node(janet_tuple_head(t1), janet_tuple_head(t2), 0); ------------------ | | 1800| 45.8k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) ------------------ 37350| 45.8k| break; 37351| 45.8k| } 37352| 280| case JANET_STRUCT: { ------------------ | Branch (37352:13): [True: 280, False: 526k] ------------------ 37353| 280| const JanetKV *s1 = janet_unwrap_struct(x); ------------------ | | 857| 280|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37354| 280| const JanetKV *s2 = janet_unwrap_struct(y); ------------------ | | 857| 280|#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x)) ------------------ 37355| 280| if (s1 == s2) break; ------------------ | Branch (37355:21): [True: 0, False: 280] ------------------ 37356| 280| if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1850| 280|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 280|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_hash(s1) != janet_struct_hash(s2)) return 0; ------------------ | | 1850| 280|#define janet_struct_hash(t) (janet_struct_head(t)->hash) | | ------------------ | | | | 1846| 280|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37356:21): [True: 138, False: 142] ------------------ 37357| 142| if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1848| 142|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (janet_struct_length(s1) != janet_struct_length(s2)) return 0; ------------------ | | 1848| 142|#define janet_struct_length(t) (janet_struct_head(t)->length) | | ------------------ | | | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37357:21): [True: 0, False: 142] ------------------ 37358| 142| if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1851| 284|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 142] | | ------------------ ------------------ if (janet_struct_proto(s1) && !janet_struct_proto(s2)) return 0; ------------------ | | 1851| 0|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 0|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ | Branch (37358:47): [True: 0, False: 0] ------------------ 37359| 142| if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1851| 284|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ ------------------ if (!janet_struct_proto(s1) && janet_struct_proto(s2)) return 0; ------------------ | | 1851| 142|#define janet_struct_proto(t) (janet_struct_head(t)->proto) | | ------------------ | | | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) | | ------------------ | | | Branch (1851:31): [True: 0, False: 142] | | ------------------ ------------------ | Branch (37359:21): [True: 142, False: 0] ------------------ 37360| 142| push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ push_traversal_node(janet_struct_head(s1), janet_struct_head(s2), 0); ------------------ | | 1846| 142|#define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data))) ------------------ 37361| 142| break; 37362| 142| } 37363| 526k| } 37364| 526k| } while (!traversal_next(&x, &y)); ------------------ | Branch (37364:14): [True: 92.0k, False: 11.7k] ------------------ 37365| 11.7k| return 1; 37366| 434k|} janet.c:janet_equals_leaf: 37321| 39.4M|static int janet_equals_leaf(Janet x, Janet y) { 37322| 39.4M| switch (janet_type(x)) { ------------------ | | 795| 39.4M| (isnan((x).number) \ | | 796| 39.4M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 39.4M| : JANET_NUMBER) ------------------ | Branch (37322:13): [True: 37.9M, False: 1.57M] ------------------ 37323| 1.57M| case JANET_NUMBER: ------------------ | Branch (37323:9): [True: 1.57M, False: 37.9M] ------------------ 37324| 1.57M| return janet_unwrap_number(x) == janet_unwrap_number(y); ------------------ | | 839| 1.57M|#define janet_unwrap_number(x) ((x).number) ------------------ return janet_unwrap_number(x) == janet_unwrap_number(y); ------------------ | | 839| 1.57M|#define janet_unwrap_number(x) ((x).number) ------------------ 37325| 1.43M| case JANET_STRING: ------------------ | Branch (37325:9): [True: 1.43M, False: 38.0M] ------------------ 37326| 1.43M| return janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 1.43M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ return janet_string_equal(janet_unwrap_string(x), janet_unwrap_string(y)); ------------------ | | 863| 1.43M|#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x)) ------------------ 37327| 183| case JANET_ABSTRACT: ------------------ | Branch (37327:9): [True: 183, False: 39.4M] ------------------ 37328| 183| return !janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 183|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ return !janet_compare_abstract(janet_unwrap_abstract(x), janet_unwrap_abstract(y)); ------------------ | | 866| 183|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 37329| 36.4M| default: ------------------ | Branch (37329:9): [True: 36.4M, False: 3.01M] ------------------ 37330| 36.4M| return janet_bitwise_same(x, y); ------------------ | | 401| 36.4M|#define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 36.4M|#define janet_u64(x) ((x).u64) | | ------------------ | | #define janet_bitwise_same(x, y) (janet_u64(x) == janet_u64(y)) | | ------------------ | | | | 788| 36.4M|#define janet_u64(x) ((x).u64) | | ------------------ ------------------ 37331| 39.4M| } 37332| 39.4M|} janet.c:murmur64: 37374| 23.8M|static uint64_t murmur64(uint64_t h) { 37375| 23.8M| h ^= h >> 33; 37376| 23.8M| h *= 0xff51afd7ed558ccdUL; 37377| 23.8M| h ^= h >> 33; 37378| 23.8M| h *= 0xc4ceb9fe1a85ec53UL; 37379| 23.8M| h ^= h >> 33; 37380| 23.8M| return h; 37381| 23.8M|} janet.c:janet_compare_abstract: 37307| 183|static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) { 37308| 183| if (xx == yy) return 0; ------------------ | Branch (37308:9): [True: 180, False: 3] ------------------ 37309| 3| const JanetAbstractType *xt = janet_abstract_type(xx); ------------------ | | 1899| 3|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 3|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37310| 3| const JanetAbstractType *yt = janet_abstract_type(yy); ------------------ | | 1899| 3|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 3|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 37311| 3| if (xt != yt) { ------------------ | Branch (37311:9): [True: 0, False: 3] ------------------ 37312| 0| return xt > yt ? 1 : -1; ------------------ | Branch (37312:16): [True: 0, False: 0] ------------------ 37313| 0| } 37314| 3| if (xt->compare == NULL) { ------------------ | Branch (37314:9): [True: 3, False: 0] ------------------ 37315| 3| return xx > yy ? 1 : -1; ------------------ | Branch (37315:16): [True: 0, False: 3] ------------------ 37316| 3| } 37317| 0| return xt->compare(xx, yy); 37318| 3|} janet.c:push_traversal_node: 37105| 559k|static void push_traversal_node(void *lhs, void *rhs, int32_t index2) { 37106| 559k| JanetTraversalNode node; 37107| 559k| node.self = (JanetGCObject *) lhs; 37108| 559k| node.other = (JanetGCObject *) rhs; 37109| 559k| node.index = 0; 37110| 559k| node.index2 = index2; 37111| 559k| int is_new = janet_vm.traversal_base == NULL; 37112| 559k| if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) { ------------------ | Branch (37112:9): [True: 66, False: 559k] | Branch (37112:19): [True: 8, False: 559k] ------------------ 37113| 74| size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base); ------------------ | Branch (37113:26): [True: 66, False: 8] ------------------ 37114| 74| size_t newsize = 2 * oldsize + 1; 37115| 74| if (newsize < 128) { ------------------ | Branch (37115:13): [True: 66, False: 8] ------------------ 37116| 66| newsize = 128; 37117| 66| } 37118| 74| JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode)); ------------------ | | 2409| 74|#define janet_realloc(X, Y) realloc((X), (Y)) ------------------ 37119| 74| if (tn == NULL) { ------------------ | Branch (37119:13): [True: 0, False: 74] ------------------ 37120| 0| JANET_OUT_OF_MEMORY; ------------------ | | 419| 0|#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0) | | ------------------ | | | Branch (419:122): [Folded, False: 0] | | ------------------ ------------------ 37121| 0| } 37122| 74| janet_vm.traversal_base = tn; 37123| 74| janet_vm.traversal_top = janet_vm.traversal_base + newsize; 37124| 74| janet_vm.traversal = janet_vm.traversal_base + oldsize; 37125| 74| } 37126| 559k| *(++janet_vm.traversal) = node; 37127| 559k|} janet.c:traversal_next: 37137| 1.72M|static int traversal_next(Janet *x, Janet *y) { 37138| 1.72M| JanetTraversalNode *t = janet_vm.traversal; 37139| 2.04M| while (t && t > janet_vm.traversal_base) { ------------------ | Branch (37139:12): [True: 2.00M, False: 33.6k] | Branch (37139:17): [True: 1.43M, False: 571k] ------------------ 37140| 1.43M| JanetGCObject *self = t->self; 37141| 1.43M| JanetTupleHead *tself = (JanetTupleHead *)self; 37142| 1.43M| JanetStructHead *sself = (JanetStructHead *)self; 37143| 1.43M| JanetGCObject *other = t->other; 37144| 1.43M| JanetTupleHead *tother = (JanetTupleHead *)other; 37145| 1.43M| JanetStructHead *sother = (JanetStructHead *)other; 37146| 1.43M| if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) { ------------------ | | 675| 1.43M|#define JANET_MEM_TYPEBITS 0xFF ------------------ | Branch (37146:13): [True: 1.43M, False: 443] ------------------ 37147| | /* Node is a tuple at index t->index */ 37148| 1.43M| if (t->index < tself->length && t->index < tother->length) { ------------------ | Branch (37148:17): [True: 1.11M, False: 316k] | Branch (37148:45): [True: 1.11M, False: 0] ------------------ 37149| 1.11M| int32_t index = t->index++; 37150| 1.11M| *x = tself->data[index]; 37151| 1.11M| *y = tother->data[index]; 37152| 1.11M| janet_vm.traversal = t; 37153| 1.11M| return 0; 37154| 1.11M| } 37155| 316k| if (t->index2 && tself->length != tother->length) { ------------------ | Branch (37155:17): [True: 270k, False: 45.8k] | Branch (37155:30): [True: 0, False: 270k] ------------------ 37156| 0| return tself->length > tother->length ? 3 : 1; ------------------ | Branch (37156:24): [True: 0, False: 0] ------------------ 37157| 0| } 37158| 316k| } else { 37159| | /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */ 37160| 443| if (t->index2) { ------------------ | Branch (37160:17): [True: 150, False: 293] ------------------ 37161| 150| t->index2 = 0; 37162| 150| int32_t index = t->index++; 37163| 150| *x = sself->data[index].value; 37164| 150| *y = sother->data[index].value; 37165| 150| janet_vm.traversal = t; 37166| 150| return 0; 37167| 150| } 37168| 293| for (int32_t i = t->index; i < sself->capacity; i++) { ------------------ | Branch (37168:40): [True: 150, False: 143] ------------------ 37169| 150| t->index2 = 1; 37170| 150| *x = sself->data[t->index].key; 37171| 150| *y = sother->data[t->index].key; 37172| 150| janet_vm.traversal = t; 37173| 150| return 0; 37174| 150| } 37175| | /* Traverse prototype */ 37176| 143| JanetStruct sproto = sself->proto; 37177| 143| JanetStruct oproto = sother->proto; 37178| 143| if (sproto && !oproto) return 3; ------------------ | Branch (37178:17): [True: 0, False: 143] | Branch (37178:27): [True: 0, False: 0] ------------------ 37179| 143| if (!sproto && oproto) return 1; ------------------ | Branch (37179:17): [True: 143, False: 0] | Branch (37179:28): [True: 0, False: 143] ------------------ 37180| 143| if (oproto && sproto) { ------------------ | Branch (37180:17): [True: 0, False: 143] | Branch (37180:27): [True: 0, False: 0] ------------------ 37181| 0| *x = janet_wrap_struct(sproto); ------------------ | | 842| 0|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37182| 0| *y = janet_wrap_struct(oproto); ------------------ | | 842| 0|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 37183| 0| janet_vm.traversal = t - 1; 37184| 0| return 0; 37185| 0| } 37186| 143| } 37187| 316k| t--; 37188| 316k| } 37189| 605k| janet_vm.traversal = t; 37190| 605k| return 2; 37191| 1.72M|} janet.c:getter_checkint: 37517| 13.9M|static int32_t getter_checkint(JanetType type, Janet key, int32_t max) { 37518| 13.9M| if (!janet_checkint(key)) goto bad; ------------------ | Branch (37518:9): [True: 0, False: 13.9M] ------------------ 37519| 13.9M| int32_t ret = janet_unwrap_integer(key); ------------------ | | 966| 13.9M|#define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x)) | | ------------------ | | | | 839| 13.9M|#define janet_unwrap_number(x) ((x).number) | | ------------------ ------------------ 37520| 13.9M| if (ret < 0) goto bad; ------------------ | Branch (37520:9): [True: 0, False: 13.9M] ------------------ 37521| 13.9M| if (ret >= max) goto bad; ------------------ | Branch (37521:9): [True: 204, False: 13.9M] ------------------ 37522| 13.9M| return ret; 37523| 204|bad: 37524| 204| janet_panicf("expected integer key for %s in range [0, %d), got %v", janet_type_names[type], max, key); 37525| 13.9M|} janet.c:run_vm: 38301| 68.6k|static JanetSignal run_vm(JanetFiber *fiber, Janet in) { 38302| | 38303| | /* opcode -> label lookup if using clang/GCC */ 38304| 68.6k|#ifdef JANET_USE_COMPUTED_GOTOS 38305| 68.6k| static void *op_lookup[255] = { 38306| 68.6k| &&label_JOP_NOOP, 38307| 68.6k| &&label_JOP_ERROR, 38308| 68.6k| &&label_JOP_TYPECHECK, 38309| 68.6k| &&label_JOP_RETURN, 38310| 68.6k| &&label_JOP_RETURN_NIL, 38311| 68.6k| &&label_JOP_ADD_IMMEDIATE, 38312| 68.6k| &&label_JOP_ADD, 38313| 68.6k| &&label_JOP_SUBTRACT_IMMEDIATE, 38314| 68.6k| &&label_JOP_SUBTRACT, 38315| 68.6k| &&label_JOP_MULTIPLY_IMMEDIATE, 38316| 68.6k| &&label_JOP_MULTIPLY, 38317| 68.6k| &&label_JOP_DIVIDE_IMMEDIATE, 38318| 68.6k| &&label_JOP_DIVIDE, 38319| 68.6k| &&label_JOP_DIVIDE_FLOOR, 38320| 68.6k| &&label_JOP_MODULO, 38321| 68.6k| &&label_JOP_REMAINDER, 38322| 68.6k| &&label_JOP_BAND, 38323| 68.6k| &&label_JOP_BOR, 38324| 68.6k| &&label_JOP_BXOR, 38325| 68.6k| &&label_JOP_BNOT, 38326| 68.6k| &&label_JOP_SHIFT_LEFT, 38327| 68.6k| &&label_JOP_SHIFT_LEFT_IMMEDIATE, 38328| 68.6k| &&label_JOP_SHIFT_RIGHT, 38329| 68.6k| &&label_JOP_SHIFT_RIGHT_IMMEDIATE, 38330| 68.6k| &&label_JOP_SHIFT_RIGHT_UNSIGNED, 38331| 68.6k| &&label_JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE, 38332| 68.6k| &&label_JOP_MOVE_FAR, 38333| 68.6k| &&label_JOP_MOVE_NEAR, 38334| 68.6k| &&label_JOP_JUMP, 38335| 68.6k| &&label_JOP_JUMP_IF, 38336| 68.6k| &&label_JOP_JUMP_IF_NOT, 38337| 68.6k| &&label_JOP_JUMP_IF_NIL, 38338| 68.6k| &&label_JOP_JUMP_IF_NOT_NIL, 38339| 68.6k| &&label_JOP_GREATER_THAN, 38340| 68.6k| &&label_JOP_GREATER_THAN_IMMEDIATE, 38341| 68.6k| &&label_JOP_LESS_THAN, 38342| 68.6k| &&label_JOP_LESS_THAN_IMMEDIATE, 38343| 68.6k| &&label_JOP_EQUALS, 38344| 68.6k| &&label_JOP_EQUALS_IMMEDIATE, 38345| 68.6k| &&label_JOP_COMPARE, 38346| 68.6k| &&label_JOP_LOAD_NIL, 38347| 68.6k| &&label_JOP_LOAD_TRUE, 38348| 68.6k| &&label_JOP_LOAD_FALSE, 38349| 68.6k| &&label_JOP_LOAD_INTEGER, 38350| 68.6k| &&label_JOP_LOAD_CONSTANT, 38351| 68.6k| &&label_JOP_LOAD_UPVALUE, 38352| 68.6k| &&label_JOP_LOAD_SELF, 38353| 68.6k| &&label_JOP_SET_UPVALUE, 38354| 68.6k| &&label_JOP_CLOSURE, 38355| 68.6k| &&label_JOP_PUSH, 38356| 68.6k| &&label_JOP_PUSH_2, 38357| 68.6k| &&label_JOP_PUSH_3, 38358| 68.6k| &&label_JOP_PUSH_ARRAY, 38359| 68.6k| &&label_JOP_CALL, 38360| 68.6k| &&label_JOP_TAILCALL, 38361| 68.6k| &&label_JOP_RESUME, 38362| 68.6k| &&label_JOP_SIGNAL, 38363| 68.6k| &&label_JOP_PROPAGATE, 38364| 68.6k| &&label_JOP_IN, 38365| 68.6k| &&label_JOP_GET, 38366| 68.6k| &&label_JOP_PUT, 38367| 68.6k| &&label_JOP_GET_INDEX, 38368| 68.6k| &&label_JOP_PUT_INDEX, 38369| 68.6k| &&label_JOP_LENGTH, 38370| 68.6k| &&label_JOP_MAKE_ARRAY, 38371| 68.6k| &&label_JOP_MAKE_BUFFER, 38372| 68.6k| &&label_JOP_MAKE_STRING, 38373| 68.6k| &&label_JOP_MAKE_STRUCT, 38374| 68.6k| &&label_JOP_MAKE_TABLE, 38375| 68.6k| &&label_JOP_MAKE_TUPLE, 38376| 68.6k| &&label_JOP_MAKE_BRACKET_TUPLE, 38377| 68.6k| &&label_JOP_GREATER_THAN_EQUAL, 38378| 68.6k| &&label_JOP_LESS_THAN_EQUAL, 38379| 68.6k| &&label_JOP_NEXT, 38380| 68.6k| &&label_JOP_NOT_EQUALS, 38381| 68.6k| &&label_JOP_NOT_EQUALS_IMMEDIATE, 38382| 68.6k| &&label_JOP_CANCEL, 38383| 68.6k| &&label_unknown_op, 38384| 68.6k| &&label_unknown_op, 38385| 68.6k| &&label_unknown_op, 38386| 68.6k| &&label_unknown_op, 38387| 68.6k| &&label_unknown_op, 38388| 68.6k| &&label_unknown_op, 38389| 68.6k| &&label_unknown_op, 38390| 68.6k| &&label_unknown_op, 38391| 68.6k| &&label_unknown_op, 38392| 68.6k| &&label_unknown_op, 38393| 68.6k| &&label_unknown_op, 38394| 68.6k| &&label_unknown_op, 38395| 68.6k| &&label_unknown_op, 38396| 68.6k| &&label_unknown_op, 38397| 68.6k| &&label_unknown_op, 38398| 68.6k| &&label_unknown_op, 38399| 68.6k| &&label_unknown_op, 38400| 68.6k| &&label_unknown_op, 38401| 68.6k| &&label_unknown_op, 38402| 68.6k| &&label_unknown_op, 38403| 68.6k| &&label_unknown_op, 38404| 68.6k| &&label_unknown_op, 38405| 68.6k| &&label_unknown_op, 38406| 68.6k| &&label_unknown_op, 38407| 68.6k| &&label_unknown_op, 38408| 68.6k| &&label_unknown_op, 38409| 68.6k| &&label_unknown_op, 38410| 68.6k| &&label_unknown_op, 38411| 68.6k| &&label_unknown_op, 38412| 68.6k| &&label_unknown_op, 38413| 68.6k| &&label_unknown_op, 38414| 68.6k| &&label_unknown_op, 38415| 68.6k| &&label_unknown_op, 38416| 68.6k| &&label_unknown_op, 38417| 68.6k| &&label_unknown_op, 38418| 68.6k| &&label_unknown_op, 38419| 68.6k| &&label_unknown_op, 38420| 68.6k| &&label_unknown_op, 38421| 68.6k| &&label_unknown_op, 38422| 68.6k| &&label_unknown_op, 38423| 68.6k| &&label_unknown_op, 38424| 68.6k| &&label_unknown_op, 38425| 68.6k| &&label_unknown_op, 38426| 68.6k| &&label_unknown_op, 38427| 68.6k| &&label_unknown_op, 38428| 68.6k| &&label_unknown_op, 38429| 68.6k| &&label_unknown_op, 38430| 68.6k| &&label_unknown_op, 38431| 68.6k| &&label_unknown_op, 38432| 68.6k| &&label_unknown_op, 38433| 68.6k| &&label_unknown_op, 38434| 68.6k| &&label_unknown_op, 38435| 68.6k| &&label_unknown_op, 38436| 68.6k| &&label_unknown_op, 38437| 68.6k| &&label_unknown_op, 38438| 68.6k| &&label_unknown_op, 38439| 68.6k| &&label_unknown_op, 38440| 68.6k| &&label_unknown_op, 38441| 68.6k| &&label_unknown_op, 38442| 68.6k| &&label_unknown_op, 38443| 68.6k| &&label_unknown_op, 38444| 68.6k| &&label_unknown_op, 38445| 68.6k| &&label_unknown_op, 38446| 68.6k| &&label_unknown_op, 38447| 68.6k| &&label_unknown_op, 38448| 68.6k| &&label_unknown_op, 38449| 68.6k| &&label_unknown_op, 38450| 68.6k| &&label_unknown_op, 38451| 68.6k| &&label_unknown_op, 38452| 68.6k| &&label_unknown_op, 38453| 68.6k| &&label_unknown_op, 38454| 68.6k| &&label_unknown_op, 38455| 68.6k| &&label_unknown_op, 38456| 68.6k| &&label_unknown_op, 38457| 68.6k| &&label_unknown_op, 38458| 68.6k| &&label_unknown_op, 38459| 68.6k| &&label_unknown_op, 38460| 68.6k| &&label_unknown_op, 38461| 68.6k| &&label_unknown_op, 38462| 68.6k| &&label_unknown_op, 38463| 68.6k| &&label_unknown_op, 38464| 68.6k| &&label_unknown_op, 38465| 68.6k| &&label_unknown_op, 38466| 68.6k| &&label_unknown_op, 38467| 68.6k| &&label_unknown_op, 38468| 68.6k| &&label_unknown_op, 38469| 68.6k| &&label_unknown_op, 38470| 68.6k| &&label_unknown_op, 38471| 68.6k| &&label_unknown_op, 38472| 68.6k| &&label_unknown_op, 38473| 68.6k| &&label_unknown_op, 38474| 68.6k| &&label_unknown_op, 38475| 68.6k| &&label_unknown_op, 38476| 68.6k| &&label_unknown_op, 38477| 68.6k| &&label_unknown_op, 38478| 68.6k| &&label_unknown_op, 38479| 68.6k| &&label_unknown_op, 38480| 68.6k| &&label_unknown_op, 38481| 68.6k| &&label_unknown_op, 38482| 68.6k| &&label_unknown_op, 38483| 68.6k| &&label_unknown_op, 38484| 68.6k| &&label_unknown_op, 38485| 68.6k| &&label_unknown_op, 38486| 68.6k| &&label_unknown_op, 38487| 68.6k| &&label_unknown_op, 38488| 68.6k| &&label_unknown_op, 38489| 68.6k| &&label_unknown_op, 38490| 68.6k| &&label_unknown_op, 38491| 68.6k| &&label_unknown_op, 38492| 68.6k| &&label_unknown_op, 38493| 68.6k| &&label_unknown_op, 38494| 68.6k| &&label_unknown_op, 38495| 68.6k| &&label_unknown_op, 38496| 68.6k| &&label_unknown_op, 38497| 68.6k| &&label_unknown_op, 38498| 68.6k| &&label_unknown_op, 38499| 68.6k| &&label_unknown_op, 38500| 68.6k| &&label_unknown_op, 38501| 68.6k| &&label_unknown_op, 38502| 68.6k| &&label_unknown_op, 38503| 68.6k| &&label_unknown_op, 38504| 68.6k| &&label_unknown_op, 38505| 68.6k| &&label_unknown_op, 38506| 68.6k| &&label_unknown_op, 38507| 68.6k| &&label_unknown_op, 38508| 68.6k| &&label_unknown_op, 38509| 68.6k| &&label_unknown_op, 38510| 68.6k| &&label_unknown_op, 38511| 68.6k| &&label_unknown_op, 38512| 68.6k| &&label_unknown_op, 38513| 68.6k| &&label_unknown_op, 38514| 68.6k| &&label_unknown_op, 38515| 68.6k| &&label_unknown_op, 38516| 68.6k| &&label_unknown_op, 38517| 68.6k| &&label_unknown_op, 38518| 68.6k| &&label_unknown_op, 38519| 68.6k| &&label_unknown_op, 38520| 68.6k| &&label_unknown_op, 38521| 68.6k| &&label_unknown_op, 38522| 68.6k| &&label_unknown_op, 38523| 68.6k| &&label_unknown_op, 38524| 68.6k| &&label_unknown_op, 38525| 68.6k| &&label_unknown_op, 38526| 68.6k| &&label_unknown_op, 38527| 68.6k| &&label_unknown_op, 38528| 68.6k| &&label_unknown_op, 38529| 68.6k| &&label_unknown_op, 38530| 68.6k| &&label_unknown_op, 38531| 68.6k| &&label_unknown_op, 38532| 68.6k| &&label_unknown_op, 38533| 68.6k| &&label_unknown_op, 38534| 68.6k| &&label_unknown_op, 38535| 68.6k| &&label_unknown_op, 38536| 68.6k| &&label_unknown_op, 38537| 68.6k| &&label_unknown_op, 38538| 68.6k| &&label_unknown_op, 38539| 68.6k| &&label_unknown_op, 38540| 68.6k| &&label_unknown_op, 38541| 68.6k| &&label_unknown_op, 38542| 68.6k| &&label_unknown_op, 38543| 68.6k| &&label_unknown_op, 38544| 68.6k| &&label_unknown_op, 38545| 68.6k| &&label_unknown_op, 38546| 68.6k| &&label_unknown_op, 38547| 68.6k| &&label_unknown_op, 38548| 68.6k| &&label_unknown_op, 38549| 68.6k| &&label_unknown_op, 38550| 68.6k| &&label_unknown_op, 38551| 68.6k| &&label_unknown_op, 38552| 68.6k| &&label_unknown_op, 38553| 68.6k| &&label_unknown_op, 38554| 68.6k| &&label_unknown_op, 38555| 68.6k| &&label_unknown_op, 38556| 68.6k| &&label_unknown_op, 38557| 68.6k| &&label_unknown_op, 38558| 68.6k| &&label_unknown_op, 38559| 68.6k| &&label_unknown_op, 38560| 68.6k| &&label_unknown_op 38561| 68.6k| }; 38562| 68.6k|#endif 38563| | 38564| | /* Interpreter state */ 38565| 68.6k| register Janet *stack; 38566| 68.6k| register uint32_t *pc; 38567| 68.6k| register JanetFunction *func; 38568| | 38569| | /* NOTE: Flag smuggling! We "smuggle" the fiber sigal in the gc.flags field instead of the usual flags field */ 38570| 68.6k| if (fiber->flags & JANET_FIBER_RESUME_SIGNAL) { ------------------ | | 831| 68.6k|#define JANET_FIBER_RESUME_SIGNAL 0x400000 ------------------ | Branch (38570:9): [True: 0, False: 68.6k] ------------------ 38571| | /* Get the signal */ 38572| 0| JanetSignal sig = (fiber->gc.flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 830| 0|#define JANET_FIBER_STATUS_MASK 0x3F0000 ------------------ JanetSignal sig = (fiber->gc.flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET; ------------------ | | 832| 0|#define JANET_FIBER_STATUS_OFFSET 16 ------------------ 38573| | /* Clear the signal */ 38574| 0| fiber->gc.flags &= ~JANET_FIBER_STATUS_MASK; ------------------ | | 830| 0|#define JANET_FIBER_STATUS_MASK 0x3F0000 ------------------ 38575| 0| fiber->flags &= ~JANET_FIBER_RESUME_SIGNAL; ------------------ | | 831| 0|#define JANET_FIBER_RESUME_SIGNAL 0x400000 ------------------ 38576| 0| janet_vm.return_reg[0] = in; 38577| 0| return sig; 38578| 0| } 38579| | 38580| 68.6k| vm_restore(); ------------------ | |38025| 68.6k|#define vm_restore() do { \ | |38026| 68.6k| stack = fiber->data + fiber->frame; \ | |38027| 68.6k| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 68.6k|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 68.6k|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 68.6k| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 68.6k|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 68.6k|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 68.6k|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 68.6k] | | ------------------ ------------------ 38581| | 38582| 68.6k| if (fiber->flags & JANET_FIBER_DID_LONGJUMP) { ------------------ | | 837| 68.6k|#define JANET_FIBER_DID_LONGJUMP 0x8000000 ------------------ | Branch (38582:9): [True: 0, False: 68.6k] ------------------ 38583| 0| if (janet_fiber_frame(fiber)->func == NULL) { ------------------ | | 855| 0|#define janet_fiber_frame(f) janet_stack_frame((f)->data + (f)->frame) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ ------------------ | Branch (38583:13): [True: 0, False: 0] ------------------ 38584| | /* Inside a c function */ 38585| 0| janet_fiber_popframe(fiber); 38586| 0| vm_restore(); ------------------ | |38025| 0|#define vm_restore() do { \ | |38026| 0| stack = fiber->data + fiber->frame; \ | |38027| 0| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 0| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 0|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 0] | | ------------------ ------------------ 38587| 0| } 38588| | /* Check if we were at a tail call instruction. If so, do implicit return */ 38589| 0| if ((*pc & 0xFF) == JOP_TAILCALL) { ------------------ | Branch (38589:13): [True: 0, False: 0] ------------------ 38590| | /* Tail call resume */ 38591| 0| int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 1013| 0|#define JANET_STACKFRAME_ENTRANCE 2 ------------------ 38592| 0| janet_fiber_popframe(fiber); 38593| 0| if (entrance_frame) { ------------------ | Branch (38593:17): [True: 0, False: 0] ------------------ 38594| 0| fiber->flags &= ~JANET_FIBER_FLAG_MASK; ------------------ | | 838| 0|#define JANET_FIBER_FLAG_MASK 0xF000000 ------------------ 38595| 0| vm_return(JANET_SIGNAL_OK, in); ------------------ | |38030| 0|#define vm_return(sig, val) do { \ | |38031| 0| janet_vm.return_reg[0] = (val); \ | |38032| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38033| 0| return (sig); \ | |38034| 0|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 38596| 0| } 38597| 0| vm_restore(); ------------------ | |38025| 0|#define vm_restore() do { \ | |38026| 0| stack = fiber->data + fiber->frame; \ | |38027| 0| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 0| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 0|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 0] | | ------------------ ------------------ 38598| 0| } 38599| 0| } 38600| | 38601| 68.6k| if (!(fiber->flags & JANET_FIBER_RESUME_NO_USEVAL)) stack[A] = in; ------------------ | | 835| 68.6k|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ if (!(fiber->flags & JANET_FIBER_RESUME_NO_USEVAL)) stack[A] = in; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ | Branch (38601:9): [True: 0, False: 68.6k] ------------------ 38602| 68.6k| if (!(fiber->flags & JANET_FIBER_RESUME_NO_SKIP)) pc++; ------------------ | | 836| 68.6k|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 ------------------ | Branch (38602:9): [True: 0, False: 68.6k] ------------------ 38603| | 38604| 68.6k| uint8_t first_opcode = *pc & ((fiber->flags & JANET_FIBER_BREAKPOINT) ? 0x7F : 0xFF); ------------------ | | 834| 68.6k|#define JANET_FIBER_BREAKPOINT 0x1000000 ------------------ | Branch (38604:35): [True: 0, False: 68.6k] ------------------ 38605| | 38606| 68.6k| fiber->flags &= ~JANET_FIBER_FLAG_MASK; ------------------ | | 838| 68.6k|#define JANET_FIBER_FLAG_MASK 0xF000000 ------------------ 38607| | 38608| | /* Main interpreter loop. Semantically is a switch on 38609| | * (*pc & 0xFF) inside of an infinite loop. */ 38610| 68.6k| VM_START(); ------------------ | |38009| 68.6k|#define VM_START() { goto *op_lookup[first_opcode]; ------------------ 38611| | 38612| 68.6k| VM_DEFAULT(); ------------------ | |38012| 0|#define VM_DEFAULT() label_unknown_op: ------------------ 38613| 0| fiber->flags |= JANET_FIBER_BREAKPOINT | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; ------------------ | | 834| 0|#define JANET_FIBER_BREAKPOINT 0x1000000 ------------------ fiber->flags |= JANET_FIBER_BREAKPOINT | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; ------------------ | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ fiber->flags |= JANET_FIBER_BREAKPOINT | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP; ------------------ | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 ------------------ 38614| 0| vm_return(JANET_SIGNAL_DEBUG, janet_wrap_nil()); ------------------ | |38030| 0|#define vm_return(sig, val) do { \ | |38031| 0| janet_vm.return_reg[0] = (val); \ | |38032| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38033| 0| return (sig); \ | |38034| 0|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 38615| | 38616| 0| VM_OP(JOP_NOOP) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38617| 0| vm_pcnext(); ------------------ | |38044| 0|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38618| | 38619| 9| VM_OP(JOP_ERROR) ------------------ | |38011| 9|#define VM_OP(op) label_##op : ------------------ 38620| 9| vm_return(JANET_SIGNAL_ERROR, stack[D]); ------------------ | |38030| 9|#define vm_return(sig, val) do { \ | |38031| 9| janet_vm.return_reg[0] = (val); \ | |38032| 9| vm_commit(); \ | | ------------------ | | | |38024| 9|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 9|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 9|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 9] | | | | ------------------ | | ------------------ | |38033| 9| return (sig); \ | |38034| 9|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 38621| | 38622| 0| VM_OP(JOP_TYPECHECK) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38623| 0| vm_assert_types(stack[A], E); ------------------ | |38056| 0|#define vm_assert_types(X, TS) do { \ | |38057| 0| if (!(janet_checktypes((X), (TS)))) { \ | | ------------------ | | | | 969| 0|#define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps)) | | | | ------------------ | | | | | | 795| 0| (isnan((x).number) \ | | | | | | 796| 0| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | | | | | 797| 0| : JANET_NUMBER) | | | | ------------------ | | ------------------ | | | Branch (38057:9): [True: 0, False: 0] | | ------------------ | |38058| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38059| 0| janet_panicf("expected %T, got %v", (TS), (X)); \ | |38060| 0| } \ | |38061| 0|} while (0) | | ------------------ | | | Branch (38061:10): [Folded, False: 0] | | ------------------ ------------------ | Branch (38623:5): [True: 0, False: 0] ------------------ 38624| 0| vm_pcnext(); ------------------ | |38044| 0|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38625| | 38626| 9.31M| VM_OP(JOP_RETURN) { ------------------ | |38011| 9.31M|#define VM_OP(op) label_##op : ------------------ 38627| 9.31M| Janet retval = stack[D]; ------------------ | |37993| 9.31M|#define D (*pc >> 8) ------------------ 38628| 9.31M| int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 854| 9.31M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 9.31M|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 1013| 9.31M|#define JANET_STACKFRAME_ENTRANCE 2 ------------------ 38629| 9.31M| janet_fiber_popframe(fiber); 38630| 9.31M| if (entrance_frame) vm_return_no_restore(JANET_SIGNAL_OK, retval); ------------------ | |38035| 65.4k|#define vm_return_no_restore(sig, val) do { \ | |38036| 65.4k| janet_vm.return_reg[0] = (val); \ | |38037| 65.4k| return (sig); \ | |38038| 65.4k|} while (0) | | ------------------ | | | Branch (38038:10): [Folded, False: 0] | | ------------------ ------------------ | Branch (38630:13): [True: 65.4k, False: 9.25M] ------------------ 38631| 9.25M| vm_restore(); ------------------ | |38025| 9.25M|#define vm_restore() do { \ | |38026| 9.25M| stack = fiber->data + fiber->frame; \ | |38027| 9.25M| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 9.25M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 9.25M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 9.25M| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 9.25M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 9.25M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 9.25M|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 9.25M] | | ------------------ ------------------ 38632| 9.25M| stack[A] = retval; ------------------ | |37990| 9.25M|#define A ((*pc >> 8) & 0xFF) ------------------ 38633| 9.25M| vm_checkgc_pcnext(); ------------------ | |38045| 9.25M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 9.25M|#define maybe_collect() do {\ | | | |38042| 9.25M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 8.77M, False: 479k] | | | | | Branch (38042:85): [Folded, False: 9.25M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 9.25M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 9.25M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38634| 9.25M| } 38635| | 38636| 9| VM_OP(JOP_RETURN_NIL) { ------------------ | |38011| 9|#define VM_OP(op) label_##op : ------------------ 38637| 9| Janet retval = janet_wrap_nil(); ------------------ | | 831| 9|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 9| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 9|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 9|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38638| 9| int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 854| 9|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 9|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 1013| 9|#define JANET_STACKFRAME_ENTRANCE 2 ------------------ 38639| 9| janet_fiber_popframe(fiber); 38640| 9| if (entrance_frame) vm_return_no_restore(JANET_SIGNAL_OK, retval); ------------------ | |38035| 0|#define vm_return_no_restore(sig, val) do { \ | |38036| 0| janet_vm.return_reg[0] = (val); \ | |38037| 0| return (sig); \ | |38038| 0|} while (0) | | ------------------ | | | Branch (38038:10): [Folded, False: 0] | | ------------------ ------------------ | Branch (38640:13): [True: 0, False: 9] ------------------ 38641| 9| vm_restore(); ------------------ | |38025| 9|#define vm_restore() do { \ | |38026| 9| stack = fiber->data + fiber->frame; \ | |38027| 9| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 9|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 9|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 9| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 9|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 9|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 9|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 9] | | ------------------ ------------------ 38642| 9| stack[A] = retval; ------------------ | |37990| 9|#define A ((*pc >> 8) & 0xFF) ------------------ 38643| 9| vm_checkgc_pcnext(); ------------------ | |38045| 9|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 9|#define maybe_collect() do {\ | | | |38042| 9| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 3, False: 6] | | | | | Branch (38042:85): [Folded, False: 9] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 9|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 9|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38644| 9| } 38645| | 38646| 6.46M| VM_OP(JOP_ADD_IMMEDIATE) ------------------ | |38011| 6.46M|#define VM_OP(op) label_##op : ------------------ 38647| 6.46M| vm_binop_immediate(+); ------------------ | |38075| 6.46M| {\ | |38076| 6.46M| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 6.46M|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38077| 6.46M| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 6.46M| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [True: 6.46M, Folded] | | | | ------------------ | | | | 807| 6.46M| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 6.46M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 6.46M, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 6.46M| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38077:13): [True: 0, False: 6.46M] | | ------------------ | |38078| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38079| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38080| 0| Janet a = janet_mcall(#op, 2, _argv);\ | |38081| 0| stack = fiber->data + fiber->frame;\ | |38082| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38083| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38084| 6.46M| } else {\ | |38085| 6.46M| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 6.46M|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38086| 6.46M| stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | |37990| 6.46M|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | | 835| 6.46M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38087| 6.46M| vm_pcnext();\ | | ------------------ | | | |38044| 6.46M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 6.46M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38088| 6.46M| }\ | |38089| 6.46M| } ------------------ 38648| | 38649| 6.46M| VM_OP(JOP_ADD) ------------------ | |38011| 160k|#define VM_OP(op) label_##op : ------------------ 38650| 160k| vm_binop(+); ------------------ | |38127| 160k|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | ------------------ | | | |38111| 160k| {\ | | | |38112| 160k| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 160k|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38113| 160k| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 160k|#define C (*pc >> 24) | | | | ------------------ | | | |38114| 160k| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 321k| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 160k, False: 0] | | | | | | | Branch (806:6): [True: 160k, Folded] | | | | | | ------------------ | | | | | | 807| 321k| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 160k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 160k, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 321k| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 160k| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 160k, False: 0] | | | | | | | Branch (806:6): [True: 160k, Folded] | | | | | | ------------------ | | | | | | 807| 160k| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 160k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 160k, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 160k| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38115| 160k| double x1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 160k|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38116| 160k| double x2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 160k|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38117| 160k| stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |37990| 160k|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |38127| 160k|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | | | | | ------------------ | | | | | | | | 835| 160k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | | | ------------------ | | | | ------------------ | | | |38118| 160k| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 160k|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 160k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38119| 160k| } else {\ | | | |38120| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38121| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38122| 0| stack = fiber->data + fiber->frame;\ | | | |38123| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38124| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38125| 0| }\ | | | |38126| 160k| } | | ------------------ ------------------ 38651| | 38652| 160k| VM_OP(JOP_SUBTRACT_IMMEDIATE) ------------------ | |38011| 35.8k|#define VM_OP(op) label_##op : ------------------ 38653| 35.8k| vm_binop_immediate(-); ------------------ | |38075| 35.8k| {\ | |38076| 35.8k| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 35.8k|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38077| 35.8k| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 35.8k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [True: 35.8k, Folded] | | | | ------------------ | | | | 807| 35.8k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 35.8k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 35.8k, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 35.8k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38077:13): [True: 0, False: 35.8k] | | ------------------ | |38078| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38079| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38080| 0| Janet a = janet_mcall(#op, 2, _argv);\ | |38081| 0| stack = fiber->data + fiber->frame;\ | |38082| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38083| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38084| 35.8k| } else {\ | |38085| 35.8k| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 35.8k|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38086| 35.8k| stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | |37990| 35.8k|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | | 835| 35.8k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38087| 35.8k| vm_pcnext();\ | | ------------------ | | | |38044| 35.8k|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 35.8k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38088| 35.8k| }\ | |38089| 35.8k| } ------------------ 38654| | 38655| 35.8k| VM_OP(JOP_SUBTRACT) ------------------ | |38011| 2.76k|#define VM_OP(op) label_##op : ------------------ 38656| 2.76k| vm_binop(-); ------------------ | |38127| 2.76k|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | ------------------ | | | |38111| 2.76k| {\ | | | |38112| 2.76k| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 2.76k|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38113| 2.76k| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 2.76k|#define C (*pc >> 24) | | | | ------------------ | | | |38114| 2.76k| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 5.53k| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 2.76k, False: 0] | | | | | | | Branch (806:6): [True: 2.76k, Folded] | | | | | | ------------------ | | | | | | 807| 5.53k| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 2.76k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 2.76k, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 5.53k| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 2.76k| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 2.76k, False: 0] | | | | | | | Branch (806:6): [True: 2.76k, Folded] | | | | | | ------------------ | | | | | | 807| 2.76k| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 2.76k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 2.76k, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 2.76k| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38115| 2.76k| double x1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 2.76k|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38116| 2.76k| double x2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 2.76k|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38117| 2.76k| stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |37990| 2.76k|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |38127| 2.76k|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | | | | | ------------------ | | | | | | | | 835| 2.76k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | | | ------------------ | | | | ------------------ | | | |38118| 2.76k| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 2.76k|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 2.76k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38119| 2.76k| } else {\ | | | |38120| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38121| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38122| 0| stack = fiber->data + fiber->frame;\ | | | |38123| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38124| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38125| 0| }\ | | | |38126| 2.76k| } | | ------------------ ------------------ 38657| | 38658| 2.76k| VM_OP(JOP_MULTIPLY_IMMEDIATE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38659| 0| vm_binop_immediate(*); ------------------ | |38075| 0| {\ | |38076| 0| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38077| 0| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [True: 0, Folded] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38077:13): [True: 0, False: 0] | | ------------------ | |38078| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38079| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38080| 0| Janet a = janet_mcall(#op, 2, _argv);\ | |38081| 0| stack = fiber->data + fiber->frame;\ | |38082| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38083| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38084| 0| } else {\ | |38085| 0| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38086| 0| stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38087| 0| vm_pcnext();\ | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38088| 0| }\ | |38089| 0| } ------------------ 38660| | 38661| 0| VM_OP(JOP_MULTIPLY) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38662| 0| vm_binop(*); ------------------ | |38127| 0|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | ------------------ | | | |38111| 0| {\ | | | |38112| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38113| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38114| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38115| 0| double x1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38116| 0| double x2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38117| 0| stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |38127| 0|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | | | | | ------------------ | | | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | | | ------------------ | | | | ------------------ | | | |38118| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38119| 0| } else {\ | | | |38120| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38121| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38122| 0| stack = fiber->data + fiber->frame;\ | | | |38123| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38124| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38125| 0| }\ | | | |38126| 0| } | | ------------------ ------------------ 38663| | 38664| 487k| VM_OP(JOP_DIVIDE_IMMEDIATE) ------------------ | |38011| 487k|#define VM_OP(op) label_##op : ------------------ 38665| 487k| vm_binop_immediate( /); ------------------ | |38075| 487k| {\ | |38076| 487k| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 487k|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38077| 487k| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 487k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [True: 487k, Folded] | | | | ------------------ | | | | 807| 487k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 487k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 487k, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 487k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38077:13): [True: 0, False: 487k] | | ------------------ | |38078| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38079| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38080| 0| Janet a = janet_mcall(#op, 2, _argv);\ | |38081| 0| stack = fiber->data + fiber->frame;\ | |38082| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38083| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38084| 487k| } else {\ | |38085| 487k| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 487k|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38086| 487k| stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | |37990| 487k|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_number(x1 op CS);\ | | ------------------ | | | | 835| 487k|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ | |38087| 487k| vm_pcnext();\ | | ------------------ | | | |38044| 487k|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 487k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38088| 487k| }\ | |38089| 487k| } ------------------ 38666| | 38667| 487k| VM_OP(JOP_DIVIDE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38668| 0| vm_binop( /); ------------------ | |38127| 0|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | ------------------ | | | |38111| 0| {\ | | | |38112| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38113| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38114| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38115| 0| double x1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38116| 0| double x2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38117| 0| stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = wrap(x1 op x2);\ | | | | ------------------ | | | | | |38127| 0|#define vm_binop(op) _vm_binop(op, janet_wrap_number) | | | | | | ------------------ | | | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | | | ------------------ | | | | ------------------ | | | |38118| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38119| 0| } else {\ | | | |38120| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38121| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38122| 0| stack = fiber->data + fiber->frame;\ | | | |38123| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38124| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38125| 0| }\ | | | |38126| 0| } | | ------------------ ------------------ 38669| | 38670| 2| VM_OP(JOP_DIVIDE_FLOOR) { ------------------ | |38011| 2|#define VM_OP(op) label_##op : ------------------ 38671| 2| Janet op1 = stack[B]; ------------------ | |37991| 2|#define B ((*pc >> 16) & 0xFF) ------------------ 38672| 2| Janet op2 = stack[C]; ------------------ | |37992| 2|#define C (*pc >> 24) ------------------ 38673| 2| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { ------------------ | | 806| 4| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2, False: 0] | | | Branch (806:6): [True: 2, Folded] | | ------------------ | | 807| 4| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 2| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 2, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { ------------------ | | 806| 2| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 2, False: 0] | | | Branch (806:6): [True: 2, Folded] | | ------------------ | | 807| 2| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 2| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 2, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 2| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38674| 2| double x1 = janet_unwrap_number(op1); ------------------ | | 839| 2|#define janet_unwrap_number(x) ((x).number) ------------------ 38675| 2| double x2 = janet_unwrap_number(op2); ------------------ | | 839| 2|#define janet_unwrap_number(x) ((x).number) ------------------ 38676| 2| stack[A] = janet_wrap_number(floor(x1 / x2)); ------------------ | |37990| 2|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_number(floor(x1 / x2)); ------------------ | | 835| 2|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 38677| 2| vm_pcnext(); ------------------ | |38044| 2|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 2|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38678| 2| } else { 38679| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 38680| 0| Janet a = janet_binop_call("div", "rdiv", op1, op2); 38681| 0| stack = fiber->data + fiber->frame; 38682| 0| stack[A] = a; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 38683| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38684| 0| } 38685| 2| } 38686| | 38687| 4.49k| VM_OP(JOP_MODULO) { ------------------ | |38011| 4.49k|#define VM_OP(op) label_##op : ------------------ 38688| 4.49k| Janet op1 = stack[B]; ------------------ | |37991| 4.49k|#define B ((*pc >> 16) & 0xFF) ------------------ 38689| 4.49k| Janet op2 = stack[C]; ------------------ | |37992| 4.49k|#define C (*pc >> 24) ------------------ 38690| 4.49k| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { ------------------ | | 806| 8.99k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.49k, False: 0] | | | Branch (806:6): [True: 4.49k, Folded] | | ------------------ | | 807| 8.99k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 4.49k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 4.49k, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 8.99k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { ------------------ | | 806| 4.49k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 4.49k, False: 0] | | | Branch (806:6): [True: 4.49k, Folded] | | ------------------ | | 807| 4.49k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 4.49k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 4.49k, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 4.49k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38691| 4.49k| double x1 = janet_unwrap_number(op1); ------------------ | | 839| 4.49k|#define janet_unwrap_number(x) ((x).number) ------------------ 38692| 4.49k| double x2 = janet_unwrap_number(op2); ------------------ | | 839| 4.49k|#define janet_unwrap_number(x) ((x).number) ------------------ 38693| 4.49k| if (x2 == 0) { ------------------ | Branch (38693:17): [True: 0, False: 4.49k] ------------------ 38694| 0| stack[A] = janet_wrap_number(x1); ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_number(x1); ------------------ | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 38695| 4.49k| } else { 38696| 4.49k| double intres = x2 * floor(x1 / x2); 38697| 4.49k| stack[A] = janet_wrap_number(x1 - intres); ------------------ | |37990| 4.49k|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_number(x1 - intres); ------------------ | | 835| 4.49k|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 38698| 4.49k| } 38699| 4.49k| vm_pcnext(); ------------------ | |38044| 4.49k|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 4.49k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38700| 4.49k| } else { 38701| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 38702| 0| Janet a = janet_binop_call("mod", "rmod", op1, op2); 38703| 0| stack = fiber->data + fiber->frame; 38704| 0| stack[A] = a; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 38705| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38706| 0| } 38707| 4.49k| } 38708| | 38709| 4.49k| VM_OP(JOP_REMAINDER) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38710| 0| Janet op1 = stack[B]; ------------------ | |37991| 0|#define B ((*pc >> 16) & 0xFF) ------------------ 38711| 0| Janet op2 = stack[C]; ------------------ | |37992| 0|#define C (*pc >> 24) ------------------ 38712| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [True: 0, Folded] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [True: 0, Folded] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38713| 0| double x1 = janet_unwrap_number(op1); ------------------ | | 839| 0|#define janet_unwrap_number(x) ((x).number) ------------------ 38714| 0| double x2 = janet_unwrap_number(op2); ------------------ | | 839| 0|#define janet_unwrap_number(x) ((x).number) ------------------ 38715| 0| stack[A] = janet_wrap_number(fmod(x1, x2)); ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_number(fmod(x1, x2)); ------------------ | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) ------------------ 38716| 0| vm_pcnext(); ------------------ | |38044| 0|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38717| 0| } else { 38718| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 38719| 0| Janet a = janet_binop_call("%", "r%", op1, op2); 38720| 0| stack = fiber->data + fiber->frame; 38721| 0| stack[A] = a; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 38722| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38723| 0| } 38724| 0| } 38725| | 38726| 0| VM_OP(JOP_BAND) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38727| 0| vm_bitop(&); ------------------ | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | ------------------ | | | |38129| 0| {\ | | | |38130| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38131| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38132| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38133| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38134| 0| double y2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38135| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38136| 0| if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | ------------------ | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38137| 0| type1 x1 = (type1) y1;\ | | | |38138| 0| int32_t x2 = (int32_t) y2;\ | | | |38139| 0| stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38140| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38141| 0| } else {\ | | | |38142| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38143| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38144| 0| stack = fiber->data + fiber->frame;\ | | | |38145| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38146| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38147| 0| }\ | | | |38148| 0| } | | ------------------ ------------------ 38728| | 38729| 0| VM_OP(JOP_BOR) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38730| 0| vm_bitop( |); ------------------ | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | ------------------ | | | |38129| 0| {\ | | | |38130| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38131| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38132| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38133| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38134| 0| double y2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38135| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38136| 0| if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | ------------------ | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38137| 0| type1 x1 = (type1) y1;\ | | | |38138| 0| int32_t x2 = (int32_t) y2;\ | | | |38139| 0| stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38140| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38141| 0| } else {\ | | | |38142| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38143| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38144| 0| stack = fiber->data + fiber->frame;\ | | | |38145| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38146| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38147| 0| }\ | | | |38148| 0| } | | ------------------ ------------------ 38731| | 38732| 0| VM_OP(JOP_BXOR) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38733| 0| vm_bitop(^); ------------------ | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | ------------------ | | | |38129| 0| {\ | | | |38130| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38131| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38132| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38133| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38134| 0| double y2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38135| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38136| 0| if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | ------------------ | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38137| 0| type1 x1 = (type1) y1;\ | | | |38138| 0| int32_t x2 = (int32_t) y2;\ | | | |38139| 0| stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38140| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38141| 0| } else {\ | | | |38142| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38143| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38144| 0| stack = fiber->data + fiber->frame;\ | | | |38145| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38146| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38147| 0| }\ | | | |38148| 0| } | | ------------------ ------------------ 38734| | 38735| 0| VM_OP(JOP_BNOT) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38736| 0| Janet op = stack[E]; ------------------ | |37994| 0|#define E (*pc >> 16) ------------------ 38737| 0| if (janet_checktype(op, JANET_NUMBER)) { ------------------ | | 806| 0| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 0] | | | Branch (806:6): [True: 0, Folded] | | ------------------ | | 807| 0| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38738| 0| stack[A] = janet_wrap_integer(~janet_unwrap_integer(op)); ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_integer(~janet_unwrap_integer(op)); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 38739| 0| vm_pcnext(); ------------------ | |38044| 0|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38740| 0| } else { 38741| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 38742| 0| Janet a = janet_unary_call("~", op); 38743| 0| stack = fiber->data + fiber->frame; 38744| 0| stack[A] = a; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 38745| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38746| 0| } 38747| 0| } 38748| | 38749| 0| VM_OP(JOP_SHIFT_RIGHT_UNSIGNED) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38750| 0| vm_bitopu( >>); ------------------ | |38150| 0|#define vm_bitopu(op) _vm_bitop(op, uint32_t, janet_checkuintrange, "32-bit unsigned integers") | | ------------------ | | | |38129| 0| {\ | | | |38130| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38131| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38132| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38133| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38134| 0| double y2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38135| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38150| 0|#define vm_bitopu(op) _vm_bitop(op, uint32_t, janet_checkuintrange, "32-bit unsigned integers") | | | | | | ------------------ | | | | | | | | 963| 0|#define janet_checkuintrange(x) ((x) >= 0 && (x) <= UINT32_MAX && (x) == (uint32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (963:34): [True: 0, False: 0] | | | | | | | | | Branch (963:46): [True: 0, False: 0] | | | | | | | | | Branch (963:67): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38136| 0| if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | ------------------ | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38137| 0| type1 x1 = (type1) y1;\ | | | |38138| 0| int32_t x2 = (int32_t) y2;\ | | | |38139| 0| stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38140| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38141| 0| } else {\ | | | |38142| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38143| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38144| 0| stack = fiber->data + fiber->frame;\ | | | |38145| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38146| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38147| 0| }\ | | | |38148| 0| } | | ------------------ ------------------ 38751| | 38752| 0| VM_OP(JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38753| 0| vm_bitopu_immediate( >>); ------------------ | |38109| 0|#define vm_bitopu_immediate(op) _vm_bitop_immediate(op, uint32_t, janet_checkuintrange, "32-bit unsigned integers"); | | ------------------ | | | |38091| 0| {\ | | | |38092| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38093| 0| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38093:13): [True: 0, False: 0] | | | | ------------------ | | | |38094| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38095| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38096| 0| Janet a = janet_mcall(#op, 2, _argv);\ | | | |38097| 0| stack = fiber->data + fiber->frame;\ | | | |38098| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38099| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38100| 0| } else {\ | | | |38101| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38102| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38109| 0|#define vm_bitopu_immediate(op) _vm_bitop_immediate(op, uint32_t, janet_checkuintrange, "32-bit unsigned integers"); | | | | | | ------------------ | | | | | | | | 963| 0|#define janet_checkuintrange(x) ((x) >= 0 && (x) <= UINT32_MAX && (x) == (uint32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (963:34): [True: 0, False: 0] | | | | | | | | | Branch (963:46): [True: 0, False: 0] | | | | | | | | | Branch (963:67): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38103| 0| type1 x1 = (type1) y1;\ | | | |38104| 0| stack[A] = janet_wrap_number((type1) (x1 op CS));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op CS));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38105| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38106| 0| }\ | | | |38107| 0| } | | ------------------ ------------------ 38754| | 38755| 0| VM_OP(JOP_SHIFT_RIGHT) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38756| 0| vm_bitop( >>); ------------------ | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | ------------------ | | | |38129| 0| {\ | | | |38130| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38131| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38132| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38133| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38134| 0| double y2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38135| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38136| 0| if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | ------------------ | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38137| 0| type1 x1 = (type1) y1;\ | | | |38138| 0| int32_t x2 = (int32_t) y2;\ | | | |38139| 0| stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38140| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38141| 0| } else {\ | | | |38142| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38143| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38144| 0| stack = fiber->data + fiber->frame;\ | | | |38145| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38146| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38147| 0| }\ | | | |38148| 0| } | | ------------------ ------------------ 38757| | 38758| 0| VM_OP(JOP_SHIFT_RIGHT_IMMEDIATE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38759| 0| vm_bitop_immediate( >>); ------------------ | |38108| 0|#define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t, janet_checkintrange, "32-bit signed integers"); | | ------------------ | | | |38091| 0| {\ | | | |38092| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38093| 0| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38093:13): [True: 0, False: 0] | | | | ------------------ | | | |38094| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38095| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38096| 0| Janet a = janet_mcall(#op, 2, _argv);\ | | | |38097| 0| stack = fiber->data + fiber->frame;\ | | | |38098| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38099| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38100| 0| } else {\ | | | |38101| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38102| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38108| 0|#define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t, janet_checkintrange, "32-bit signed integers"); | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38103| 0| type1 x1 = (type1) y1;\ | | | |38104| 0| stack[A] = janet_wrap_number((type1) (x1 op CS));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op CS));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38105| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38106| 0| }\ | | | |38107| 0| } | | ------------------ ------------------ 38760| | 38761| 0| VM_OP(JOP_SHIFT_LEFT) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38762| 0| vm_bitop( <<); ------------------ | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | ------------------ | | | |38129| 0| {\ | | | |38130| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38131| 0| Janet op2 = stack[C];\ | | | | ------------------ | | | | | |37992| 0|#define C (*pc >> 24) | | | | ------------------ | | | |38132| 0| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:5): [True: 0, False: 0] | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38133| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38134| 0| double y2 = janet_unwrap_number(op2);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38135| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38149| 0|#define vm_bitop(op) _vm_bitop(op, int32_t, janet_checkintrange, "32-bit signed integers") | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38136| 0| if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | ------------------ | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if (!janet_checkintrange(y2)) { vm_commit(); janet_panicf("rhs must be valid 32-bit signed integer, got %f", op2); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38137| 0| type1 x1 = (type1) y1;\ | | | |38138| 0| int32_t x2 = (int32_t) y2;\ | | | |38139| 0| stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op x2));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38140| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38141| 0| } else {\ | | | |38142| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38143| 0| Janet a = janet_binop_call(#op, "r" #op, op1, op2);\ | | | |38144| 0| stack = fiber->data + fiber->frame;\ | | | |38145| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38146| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38147| 0| }\ | | | |38148| 0| } | | ------------------ ------------------ 38763| | 38764| 0| VM_OP(JOP_SHIFT_LEFT_IMMEDIATE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38765| 0| vm_bitop_immediate( <<); ------------------ | |38108| 0|#define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t, janet_checkintrange, "32-bit signed integers"); | | ------------------ | | | |38091| 0| {\ | | | |38092| 0| Janet op1 = stack[B];\ | | | | ------------------ | | | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | | | ------------------ | | | |38093| 0| if (!janet_checktype(op1, JANET_NUMBER)) {\ | | | | ------------------ | | | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | | | ------------------ | | | | | | | Branch (806:6): [True: 0, Folded] | | | | | | ------------------ | | | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | | | ------------------ | | | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | | | ------------------ | | | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | | | ------------------ | | | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | | | ------------------ | | | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | | | ------------------ | | | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | | | ------------------ | | | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38093:13): [True: 0, False: 0] | | | | ------------------ | | | |38094| 0| vm_commit();\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38095| 0| Janet _argv[2] = { op1, janet_wrap_number(CS) };\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38096| 0| Janet a = janet_mcall(#op, 2, _argv);\ | | | |38097| 0| stack = fiber->data + fiber->frame;\ | | | |38098| 0| stack[A] = a;\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | |38099| 0| vm_checkgc_pcnext();\ | | | | ------------------ | | | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | | | ------------------ | | | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | | | ------------------ | | | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | |38100| 0| } else {\ | | | |38101| 0| double y1 = janet_unwrap_number(op1);\ | | | | ------------------ | | | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | | | ------------------ | | | |38102| 0| if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38108| 0|#define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t, janet_checkintrange, "32-bit signed integers"); | | | | | | ------------------ | | | | | | | | 962| 0|#define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x)) | | | | | | | | ------------------ | | | | | | | | | Branch (962:33): [True: 0, False: 0] | | | | | | | | | Branch (962:53): [True: 0, False: 0] | | | | | | | | | Branch (962:73): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (!rangecheck(y1)) { vm_commit(); janet_panicf("value %v out of range for " msg, op1); }\ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38103| 0| type1 x1 = (type1) y1;\ | | | |38104| 0| stack[A] = janet_wrap_number((type1) (x1 op CS));\ | | | | ------------------ | | | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | | | ------------------ | | | | stack[A] = janet_wrap_number((type1) (x1 op CS));\ | | | | ------------------ | | | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | | | ------------------ | | | |38105| 0| vm_pcnext();\ | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | | |38106| 0| }\ | | | |38107| 0| } | | ------------------ ------------------ 38766| | 38767| 65.5M| VM_OP(JOP_MOVE_NEAR) ------------------ | |38011| 65.5M|#define VM_OP(op) label_##op : ------------------ 38768| 65.5M| stack[A] = stack[E]; ------------------ | |37990| 65.5M|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = stack[E]; ------------------ | |37994| 65.5M|#define E (*pc >> 16) ------------------ 38769| 65.5M| vm_pcnext(); ------------------ | |38044| 65.5M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 65.5M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38770| | 38771| 65.5M| VM_OP(JOP_MOVE_FAR) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38772| 0| stack[E] = stack[A]; ------------------ | |37994| 0|#define E (*pc >> 16) ------------------ stack[E] = stack[A]; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 38773| 0| vm_pcnext(); ------------------ | |38044| 0|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38774| | 38775| 13.1M| VM_OP(JOP_JUMP) ------------------ | |38011| 13.1M|#define VM_OP(op) label_##op : ------------------ 38776| 13.1M| vm_maybe_auto_suspend(DS <= 0); ------------------ | |38065| 13.1M|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 13.1M| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 7.88M, False: 5.23M] | | | Branch (38066:19): [True: 0, False: 7.88M] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 13.1M|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 13.1M] | | ------------------ ------------------ 38777| 13.1M| pc += DS; ------------------ | |37998| 13.1M|#define DS (*((int32_t *)pc) >> 8) ------------------ 38778| 13.1M| vm_next(); ------------------ | |38013| 13.1M|#define vm_next() goto *op_lookup[*pc & 0xFF] ------------------ 38779| | 38780| 13.1M| VM_OP(JOP_JUMP_IF) ------------------ | |38011| 2.76k|#define VM_OP(op) label_##op : ------------------ 38781| 2.76k| if (janet_truthy(stack[A])) { ------------------ | | 818| 2.76k| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 5.53k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 2.76k] | | | | ------------------ | | | | 807| 5.53k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 5.53k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 2.76k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 2.76k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 2.76k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.76k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 2.76k, False: 0] | | ------------------ | | 819| 2.76k| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 5.53k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 2.76k] | | | | ------------------ | | | | 807| 5.53k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 5.53k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 2.76k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 2.76k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 2.76k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 2.76k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 0, False: 2.76k] | | | Branch (819:47): [True: 0, False: 2.76k] | | ------------------ ------------------ 38782| 0| vm_maybe_auto_suspend(ES <= 0); ------------------ | |38065| 0|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 0| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 0, False: 0] | | | Branch (38066:19): [True: 0, False: 0] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 0|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 0] | | ------------------ ------------------ 38783| 0| pc += ES; ------------------ | |37999| 0|#define ES (*((int32_t *)pc) >> 16) ------------------ 38784| 2.76k| } else { 38785| 2.76k| pc++; 38786| 2.76k| } 38787| 2.76k| vm_next(); ------------------ | |38013| 2.76k|#define vm_next() goto *op_lookup[*pc & 0xFF] ------------------ 38788| | 38789| 51.4M| VM_OP(JOP_JUMP_IF_NOT) ------------------ | |38011| 51.4M|#define VM_OP(op) label_##op : ------------------ 38790| 51.4M| if (janet_truthy(stack[A])) { ------------------ | | 818| 51.4M| (!janet_checktype((x), JANET_NIL) && \ | | ------------------ | | | | 806| 102M| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 51.4M] | | | | ------------------ | | | | 807| 102M| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 102M| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 51.4M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 51.4M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 51.4M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 51.4M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (818:6): [True: 49.5M, False: 1.84M] | | ------------------ | | 819| 51.4M| (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1))) | | ------------------ | | | | 806| 99.1M| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 49.5M] | | | | ------------------ | | | | 807| 99.1M| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 99.1M| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 49.5M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 49.5M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 49.5M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 49.5M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (819:7): [True: 2.54M, False: 47.0M] | | | Branch (819:47): [True: 15.3M, False: 31.6M] | | ------------------ ------------------ 38791| 17.8M| pc++; 38792| 33.5M| } else { 38793| 33.5M| vm_maybe_auto_suspend(ES <= 0); ------------------ | |38065| 33.5M|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 33.5M| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 0, False: 33.5M] | | | Branch (38066:19): [True: 0, False: 0] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 33.5M|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 33.5M] | | ------------------ ------------------ 38794| 33.5M| pc += ES; ------------------ | |37999| 33.5M|#define ES (*((int32_t *)pc) >> 16) ------------------ 38795| 33.5M| } 38796| 51.4M| vm_next(); ------------------ | |38013| 51.4M|#define vm_next() goto *op_lookup[*pc & 0xFF] ------------------ 38797| | 38798| 51.4M| VM_OP(JOP_JUMP_IF_NIL) ------------------ | |38011| 3.45M|#define VM_OP(op) label_##op : ------------------ 38799| 3.45M| if (janet_checktype(stack[A], JANET_NIL)) { ------------------ | | 806| 3.45M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.05M, False: 2.39M] | | | Branch (806:6): [Folded, False: 3.45M] | | ------------------ | | 807| 3.45M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 3.45M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 3.45M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 3.45M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 3.45M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 3.45M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38800| 1.05M| vm_maybe_auto_suspend(ES <= 0); ------------------ | |38065| 1.05M|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 1.05M| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 0, False: 1.05M] | | | Branch (38066:19): [True: 0, False: 0] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 1.05M|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 1.05M] | | ------------------ ------------------ 38801| 1.05M| pc += ES; ------------------ | |37999| 1.05M|#define ES (*((int32_t *)pc) >> 16) ------------------ 38802| 2.39M| } else { 38803| 2.39M| pc++; 38804| 2.39M| } 38805| 3.45M| vm_next(); ------------------ | |38013| 3.45M|#define vm_next() goto *op_lookup[*pc & 0xFF] ------------------ 38806| | 38807| 3.45M| VM_OP(JOP_JUMP_IF_NOT_NIL) ------------------ | |38011| 299|#define VM_OP(op) label_##op : ------------------ 38808| 299| if (janet_checktype(stack[A], JANET_NIL)) { ------------------ | | 806| 299| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 7, False: 292] | | | Branch (806:6): [Folded, False: 299] | | ------------------ | | 807| 299| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 299| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 299| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 299|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 299|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 299|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38809| 7| pc++; 38810| 292| } else { 38811| 292| vm_maybe_auto_suspend(ES <= 0); ------------------ | |38065| 292|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 292| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 0, False: 292] | | | Branch (38066:19): [True: 0, False: 0] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 292|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 292] | | ------------------ ------------------ 38812| 292| pc += ES; ------------------ | |37999| 292|#define ES (*((int32_t *)pc) >> 16) ------------------ 38813| 292| } 38814| 299| vm_next(); ------------------ | |38013| 299|#define vm_next() goto *op_lookup[*pc & 0xFF] ------------------ 38815| | 38816| 6.96M| VM_OP(JOP_LESS_THAN) ------------------ | |38011| 6.96M|#define VM_OP(op) label_##op : ------------------ 38817| 6.96M| vm_compop( <); ------------------ | |38152| 6.96M| {\ | |38153| 6.96M| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 6.96M|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38154| 6.96M| Janet op2 = stack[C];\ | | ------------------ | | | |37992| 6.96M|#define C (*pc >> 24) | | ------------------ | |38155| 6.96M| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 13.9M| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 6.96M, False: 0] | | | | | Branch (806:6): [True: 6.96M, Folded] | | | | ------------------ | | | | 807| 13.9M| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 6.96M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 6.96M, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 13.9M| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 6.96M| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 6.96M, False: 0] | | | | | Branch (806:6): [True: 6.96M, Folded] | | | | ------------------ | | | | 807| 6.96M| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 6.96M| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 6.96M, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 6.96M| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38156| 6.96M| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 6.96M|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38157| 6.96M| double x2 = janet_unwrap_number(op2);\ | | ------------------ | | | | 839| 6.96M|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38158| 6.96M| stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | |37990| 6.96M|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | | 834| 6.96M|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 6.96M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 6.96M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 6.96M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38159| 6.96M| vm_pcnext();\ | | ------------------ | | | |38044| 6.96M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 6.96M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38160| 6.96M| } else {\ | |38161| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38162| 0| Janet a = janet_wrap_boolean(janet_compare(op1, op2) op 0);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38163| 0| stack = fiber->data + fiber->frame;\ | |38164| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38165| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38166| 0| }\ | |38167| 6.96M| } ------------------ 38818| | 38819| 6.96M| VM_OP(JOP_LESS_THAN_EQUAL) ------------------ | |38011| 9|#define VM_OP(op) label_##op : ------------------ 38820| 9| vm_compop( <=); ------------------ | |38152| 9| {\ | |38153| 9| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 9|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38154| 9| Janet op2 = stack[C];\ | | ------------------ | | | |37992| 9|#define C (*pc >> 24) | | ------------------ | |38155| 9| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 18| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 9, False: 0] | | | | | Branch (806:6): [True: 9, Folded] | | | | ------------------ | | | | 807| 18| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 9| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 9, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 18| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 9| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 9, False: 0] | | | | | Branch (806:6): [True: 9, Folded] | | | | ------------------ | | | | 807| 9| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 9| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 9, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 9| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38156| 9| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 9|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38157| 9| double x2 = janet_unwrap_number(op2);\ | | ------------------ | | | | 839| 9|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38158| 9| stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | |37990| 9|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | | 834| 9|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 9| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 9|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 9|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38159| 9| vm_pcnext();\ | | ------------------ | | | |38044| 9|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 9|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38160| 9| } else {\ | |38161| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38162| 0| Janet a = janet_wrap_boolean(janet_compare(op1, op2) op 0);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38163| 0| stack = fiber->data + fiber->frame;\ | |38164| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38165| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38166| 0| }\ | |38167| 9| } ------------------ 38821| | 38822| 9| VM_OP(JOP_LESS_THAN_IMMEDIATE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38823| 0| vm_compop_imm( <); ------------------ | |38169| 0| {\ | |38170| 0| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 0|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38171| 0| if (janet_checktype(op1, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 0, False: 0] | | | | | Branch (806:6): [True: 0, Folded] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38172| 0| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 0|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38173| 0| double x2 = (double) CS; \ | | ------------------ | | | |37997| 0|#define CS (*((int32_t *)pc) >> 24) | | ------------------ | |38174| 0| stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38175| 0| vm_pcnext();\ | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38176| 0| } else {\ | |38177| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38178| 0| Janet a = janet_wrap_boolean(janet_compare(op1, janet_wrap_integer(CS)) op 0);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38179| 0| stack = fiber->data + fiber->frame;\ | |38180| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38181| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38182| 0| }\ | |38183| 0| } ------------------ 38824| | 38825| 88.4k| VM_OP(JOP_GREATER_THAN) ------------------ | |38011| 88.4k|#define VM_OP(op) label_##op : ------------------ 38826| 88.4k| vm_compop( >); ------------------ | |38152| 88.4k| {\ | |38153| 88.4k| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 88.4k|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38154| 88.4k| Janet op2 = stack[C];\ | | ------------------ | | | |37992| 88.4k|#define C (*pc >> 24) | | ------------------ | |38155| 88.4k| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 176k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 88.4k, False: 0] | | | | | Branch (806:6): [True: 88.4k, Folded] | | | | ------------------ | | | | 807| 176k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 88.4k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 88.4k, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 176k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 88.4k| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 88.4k, False: 0] | | | | | Branch (806:6): [True: 88.4k, Folded] | | | | ------------------ | | | | 807| 88.4k| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 88.4k| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 88.4k, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 88.4k| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38156| 88.4k| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 88.4k|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38157| 88.4k| double x2 = janet_unwrap_number(op2);\ | | ------------------ | | | | 839| 88.4k|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38158| 88.4k| stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | |37990| 88.4k|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | | 834| 88.4k|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 88.4k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 88.4k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 88.4k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38159| 88.4k| vm_pcnext();\ | | ------------------ | | | |38044| 88.4k|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 88.4k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38160| 88.4k| } else {\ | |38161| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38162| 0| Janet a = janet_wrap_boolean(janet_compare(op1, op2) op 0);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38163| 0| stack = fiber->data + fiber->frame;\ | |38164| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38165| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38166| 0| }\ | |38167| 88.4k| } ------------------ 38827| | 38828| 88.4k| VM_OP(JOP_GREATER_THAN_EQUAL) ------------------ | |38011| 100|#define VM_OP(op) label_##op : ------------------ 38829| 100| vm_compop( >=); ------------------ | |38152| 100| {\ | |38153| 100| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 100|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38154| 100| Janet op2 = stack[C];\ | | ------------------ | | | |37992| 100|#define C (*pc >> 24) | | ------------------ | |38155| 100| if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 200| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 100, False: 0] | | | | | Branch (806:6): [True: 100, Folded] | | | | ------------------ | | | | 807| 200| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 100| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 100, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 200| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 100| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 100, False: 0] | | | | | Branch (806:6): [True: 100, Folded] | | | | ------------------ | | | | 807| 100| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 100| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 100, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 100| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38156| 100| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 100|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38157| 100| double x2 = janet_unwrap_number(op2);\ | | ------------------ | | | | 839| 100|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38158| 100| stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | |37990| 100|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | | 834| 100|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 100| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 100|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 100|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38159| 100| vm_pcnext();\ | | ------------------ | | | |38044| 100|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 100|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38160| 100| } else {\ | |38161| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38162| 0| Janet a = janet_wrap_boolean(janet_compare(op1, op2) op 0);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38163| 0| stack = fiber->data + fiber->frame;\ | |38164| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38165| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38166| 0| }\ | |38167| 100| } ------------------ 38830| | 38831| 752| VM_OP(JOP_GREATER_THAN_IMMEDIATE) ------------------ | |38011| 752|#define VM_OP(op) label_##op : ------------------ 38832| 752| vm_compop_imm( >); ------------------ | |38169| 752| {\ | |38170| 752| Janet op1 = stack[B];\ | | ------------------ | | | |37991| 752|#define B ((*pc >> 16) & 0xFF) | | ------------------ | |38171| 752| if (janet_checktype(op1, JANET_NUMBER)) {\ | | ------------------ | | | | 806| 752| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:5): [True: 752, False: 0] | | | | | Branch (806:6): [True: 752, Folded] | | | | ------------------ | | | | 807| 752| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 752| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 752, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 752| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38172| 752| double x1 = janet_unwrap_number(op1);\ | | ------------------ | | | | 839| 752|#define janet_unwrap_number(x) ((x).number) | | ------------------ | |38173| 752| double x2 = (double) CS; \ | | ------------------ | | | |37997| 752|#define CS (*((int32_t *)pc) >> 24) | | ------------------ | |38174| 752| stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | |37990| 752|#define A ((*pc >> 8) & 0xFF) | | ------------------ | | stack[A] = janet_wrap_boolean(x1 op x2);\ | | ------------------ | | | | 834| 752|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 752| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 752|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 752|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38175| 752| vm_pcnext();\ | | ------------------ | | | |38044| 752|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 752|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ | |38176| 752| } else {\ | |38177| 0| vm_commit();\ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38178| 0| Janet a = janet_wrap_boolean(janet_compare(op1, janet_wrap_integer(CS)) op 0);\ | | ------------------ | | | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | | | ------------------ | | | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38179| 0| stack = fiber->data + fiber->frame;\ | |38180| 0| stack[A] = a;\ | | ------------------ | | | |37990| 0|#define A ((*pc >> 8) & 0xFF) | | ------------------ | |38181| 0| vm_checkgc_pcnext();\ | | ------------------ | | | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38041| 0|#define maybe_collect() do {\ | | | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | | | ------------------ | | | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | | | Branch (38042:85): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | | | ------------------ | | | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | | | ------------------ | | | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | | | ------------------ | | | | ------------------ | | ------------------ | |38182| 0| }\ | |38183| 752| } ------------------ 38833| | 38834| 27.3M| VM_OP(JOP_EQUALS) ------------------ | |38011| 27.3M|#define VM_OP(op) label_##op : ------------------ 38835| 27.3M| stack[A] = janet_wrap_boolean(janet_equals(stack[B], stack[C])); ------------------ | |37990| 27.3M|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_boolean(janet_equals(stack[B], stack[C])); ------------------ | | 834| 27.3M|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 27.3M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 27.3M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 27.3M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38836| 27.3M| vm_pcnext(); ------------------ | |38044| 27.3M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 27.3M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38837| | 38838| 27.3M| VM_OP(JOP_EQUALS_IMMEDIATE) ------------------ | |38011| 1.04M|#define VM_OP(op) label_##op : ------------------ 38839| 1.04M| stack[A] = janet_wrap_boolean(janet_checktype(stack[B], JANET_NUMBER) && (janet_unwrap_number(stack[B]) == (double) CS)); ------------------ | |37990| 1.04M|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_boolean(janet_checktype(stack[B], JANET_NUMBER) && (janet_unwrap_number(stack[B]) == (double) CS)); ------------------ | | 834| 1.04M|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 5.24M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.04M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.04M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (822:51): [True: 1.04M, False: 0] | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [True: 1.04M, Folded] | | | | | Branch (822:51): [True: 1.04M, False: 0] | | | | | Branch (822:51): [True: 1.04M, False: 2] | | | | ------------------ | | ------------------ ------------------ 38840| 1.04M| vm_pcnext(); ------------------ | |38044| 1.04M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 1.04M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38841| | 38842| 7.80M| VM_OP(JOP_NOT_EQUALS) ------------------ | |38011| 7.80M|#define VM_OP(op) label_##op : ------------------ 38843| 7.80M| stack[A] = janet_wrap_boolean(!janet_equals(stack[B], stack[C])); ------------------ | |37990| 7.80M|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_boolean(!janet_equals(stack[B], stack[C])); ------------------ | | 834| 7.80M|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 7.80M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 7.80M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 7.80M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38844| 7.80M| vm_pcnext(); ------------------ | |38044| 7.80M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 7.80M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38845| | 38846| 7.80M| VM_OP(JOP_NOT_EQUALS_IMMEDIATE) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 38847| 0| stack[A] = janet_wrap_boolean(!janet_checktype(stack[B], JANET_NUMBER) || (janet_unwrap_number(stack[B]) != (double) CS)); ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_boolean(!janet_checktype(stack[B], JANET_NUMBER) || (janet_unwrap_number(stack[B]) != (double) CS)); ------------------ | | 834| 0|#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b)) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [True: 0, Folded] | | | | | Branch (822:51): [True: 0, False: 0] | | | | | Branch (822:51): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 38848| 0| vm_pcnext(); ------------------ | |38044| 0|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38849| | 38850| 10| VM_OP(JOP_COMPARE) { ------------------ | |38011| 10|#define VM_OP(op) label_##op : ------------------ 38851| 10| Janet a = janet_wrap_integer(janet_compare(stack[B], stack[C])); ------------------ | | 967| 10|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 10|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 38852| 10| stack = fiber->data + fiber->frame; 38853| 10| stack[A] = a; ------------------ | |37990| 10|#define A ((*pc >> 8) & 0xFF) ------------------ 38854| 10| } 38855| 10| vm_pcnext(); ------------------ | |38044| 10|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 10|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38856| | 38857| 4.21M| VM_OP(JOP_NEXT) ------------------ | |38011| 4.21M|#define VM_OP(op) label_##op : ------------------ 38858| 4.21M| vm_commit(); ------------------ | |38024| 4.21M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 4.21M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 4.21M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 4.21M] | | ------------------ ------------------ 38859| 4.21M| { 38860| 4.21M| Janet temp = janet_next_impl(stack[B], stack[C], 1); ------------------ | |37991| 4.21M|#define B ((*pc >> 16) & 0xFF) ------------------ Janet temp = janet_next_impl(stack[B], stack[C], 1); ------------------ | |37992| 4.21M|#define C (*pc >> 24) ------------------ 38861| 4.21M| vm_restore(); ------------------ | |38025| 4.21M|#define vm_restore() do { \ | |38026| 4.21M| stack = fiber->data + fiber->frame; \ | |38027| 4.21M| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 4.21M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 4.21M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 4.21M| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 4.21M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 4.21M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 4.21M|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 4.21M] | | ------------------ ------------------ 38862| 4.21M| stack[A] = temp; ------------------ | |37990| 4.21M|#define A ((*pc >> 8) & 0xFF) ------------------ 38863| 4.21M| } 38864| 4.21M| vm_pcnext(); ------------------ | |38044| 4.21M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 4.21M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38865| | 38866| 4.21M| VM_OP(JOP_LOAD_NIL) ------------------ | |38011| 1.82M|#define VM_OP(op) label_##op : ------------------ 38867| 1.82M| stack[D] = janet_wrap_nil(); ------------------ | |37993| 1.82M|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_nil(); ------------------ | | 831| 1.82M|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 1.82M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.82M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.82M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38868| 1.82M| vm_pcnext(); ------------------ | |38044| 1.82M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 1.82M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38869| | 38870| 1.82M| VM_OP(JOP_LOAD_TRUE) ------------------ | |38011| 51.6k|#define VM_OP(op) label_##op : ------------------ 38871| 51.6k| stack[D] = janet_wrap_true(); ------------------ | |37993| 51.6k|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_true(); ------------------ | | 832| 51.6k|#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1) | | ------------------ | | | | 822| 51.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 51.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 51.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38872| 51.6k| vm_pcnext(); ------------------ | |38044| 51.6k|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 51.6k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38873| | 38874| 1.76M| VM_OP(JOP_LOAD_FALSE) ------------------ | |38011| 1.76M|#define VM_OP(op) label_##op : ------------------ 38875| 1.76M| stack[D] = janet_wrap_false(); ------------------ | |37993| 1.76M|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_false(); ------------------ | | 833| 1.76M|#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0) | | ------------------ | | | | 822| 1.76M| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 1.76M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.76M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38876| 1.76M| vm_pcnext(); ------------------ | |38044| 1.76M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 1.76M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38877| | 38878| 4.38M| VM_OP(JOP_LOAD_INTEGER) ------------------ | |38011| 4.38M|#define VM_OP(op) label_##op : ------------------ 38879| 4.38M| stack[A] = janet_wrap_integer(ES); ------------------ | |37990| 4.38M|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_integer(ES); ------------------ | | 967| 4.38M|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 4.38M|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 38880| 4.38M| vm_pcnext(); ------------------ | |38044| 4.38M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 4.38M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38881| | 38882| 85.0M| VM_OP(JOP_LOAD_CONSTANT) { ------------------ | |38011| 85.0M|#define VM_OP(op) label_##op : ------------------ 38883| 85.0M| int32_t cindex = (int32_t)E; ------------------ | |37994| 85.0M|#define E (*pc >> 16) ------------------ 38884| 85.0M| vm_assert(cindex < func->def->constants_length, "invalid constant"); ------------------ | |38049| 85.0M|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 85.0M] | | | Branch (38049:69): [Folded, False: 85.0M] | | ------------------ ------------------ 38885| 85.0M| stack[A] = func->def->constants[cindex]; ------------------ | |37990| 85.0M|#define A ((*pc >> 8) & 0xFF) ------------------ 38886| 85.0M| vm_pcnext(); ------------------ | |38044| 85.0M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 85.0M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38887| 85.0M| } 38888| | 38889| 6.79M| VM_OP(JOP_LOAD_SELF) ------------------ | |38011| 6.79M|#define VM_OP(op) label_##op : ------------------ 38890| 6.79M| stack[D] = janet_wrap_function(func); ------------------ | |37993| 6.79M|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_function(func); ------------------ | | 852| 6.79M|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 825| 6.79M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 6.79M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 6.79M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38891| 6.79M| vm_pcnext(); ------------------ | |38044| 6.79M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 6.79M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38892| | 38893| 6.79M| VM_OP(JOP_LOAD_UPVALUE) { ------------------ | |38011| 4.55M|#define VM_OP(op) label_##op : ------------------ 38894| 4.55M| int32_t eindex = B; ------------------ | |37991| 4.55M|#define B ((*pc >> 16) & 0xFF) ------------------ 38895| 4.55M| int32_t vindex = C; ------------------ | |37992| 4.55M|#define C (*pc >> 24) ------------------ 38896| 4.55M| JanetFuncEnv *env; 38897| 4.55M| vm_assert(func->def->environments_length > eindex, "invalid upvalue environment"); ------------------ | |38049| 4.55M|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 4.55M] | | | Branch (38049:69): [Folded, False: 4.55M] | | ------------------ ------------------ 38898| 4.55M| env = func->envs[eindex]; 38899| 4.55M| vm_assert(env->length > vindex, "invalid upvalue index"); ------------------ | |38049| 4.55M|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 4.55M] | | | Branch (38049:69): [Folded, False: 4.55M] | | ------------------ ------------------ 38900| 4.55M| vm_assert(janet_env_valid(env), "invalid upvalue environment"); ------------------ | |38049| 4.55M|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 4.55M] | | | Branch (38049:69): [Folded, False: 4.55M] | | ------------------ ------------------ 38901| 4.55M| if (env->offset > 0) { ------------------ | Branch (38901:13): [True: 4.55M, False: 300] ------------------ 38902| | /* On stack */ 38903| 4.55M| stack[A] = env->as.fiber->data[env->offset + vindex]; ------------------ | |37990| 4.55M|#define A ((*pc >> 8) & 0xFF) ------------------ 38904| 4.55M| } else { 38905| | /* Off stack */ 38906| 300| stack[A] = env->as.values[vindex]; ------------------ | |37990| 300|#define A ((*pc >> 8) & 0xFF) ------------------ 38907| 300| } 38908| 4.55M| vm_pcnext(); ------------------ | |38044| 4.55M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 4.55M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38909| 4.55M| } 38910| | 38911| 862| VM_OP(JOP_SET_UPVALUE) { ------------------ | |38011| 862|#define VM_OP(op) label_##op : ------------------ 38912| 862| int32_t eindex = B; ------------------ | |37991| 862|#define B ((*pc >> 16) & 0xFF) ------------------ 38913| 862| int32_t vindex = C; ------------------ | |37992| 862|#define C (*pc >> 24) ------------------ 38914| 862| JanetFuncEnv *env; 38915| 862| vm_assert(func->def->environments_length > eindex, "invalid upvalue environment"); ------------------ | |38049| 862|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 862] | | | Branch (38049:69): [Folded, False: 862] | | ------------------ ------------------ 38916| 862| env = func->envs[eindex]; 38917| 862| vm_assert(env->length > vindex, "invalid upvalue index"); ------------------ | |38049| 862|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 862] | | | Branch (38049:69): [Folded, False: 862] | | ------------------ ------------------ 38918| 862| vm_assert(janet_env_valid(env), "invalid upvalue environment"); ------------------ | |38049| 862|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 862] | | | Branch (38049:69): [Folded, False: 862] | | ------------------ ------------------ 38919| 862| if (env->offset > 0) { ------------------ | Branch (38919:13): [True: 862, False: 0] ------------------ 38920| 862| env->as.fiber->data[env->offset + vindex] = stack[A]; ------------------ | |37990| 862|#define A ((*pc >> 8) & 0xFF) ------------------ 38921| 862| } else { 38922| 0| env->as.values[vindex] = stack[A]; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 38923| 0| } 38924| 862| vm_pcnext(); ------------------ | |38044| 862|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 862|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 38925| 862| } 38926| | 38927| 13.0M| VM_OP(JOP_CLOSURE) { ------------------ | |38011| 13.0M|#define VM_OP(op) label_##op : ------------------ 38928| 13.0M| JanetFuncDef *fd; 38929| 13.0M| JanetFunction *fn; 38930| 13.0M| int32_t elen; 38931| 13.0M| int32_t defindex = (int32_t)E; ------------------ | |37994| 13.0M|#define E (*pc >> 16) ------------------ 38932| 13.0M| vm_assert(defindex < func->def->defs_length, "invalid funcdef"); ------------------ | |38049| 13.0M|#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0) | | ------------------ | | | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38048:64): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38049:36): [True: 0, False: 13.0M] | | | Branch (38049:69): [Folded, False: 13.0M] | | ------------------ ------------------ 38933| 13.0M| fd = func->def->defs[defindex]; 38934| 13.0M| elen = fd->environments_length; 38935| 13.0M| fn = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + ((size_t) elen * sizeof(JanetFuncEnv *))); 38936| 13.0M| fn->def = fd; 38937| 13.0M| { 38938| 13.0M| int32_t i; 38939| 26.0M| for (i = 0; i < elen; ++i) { ------------------ | Branch (38939:25): [True: 13.0M, False: 13.0M] ------------------ 38940| 13.0M| int32_t inherit = fd->environments[i]; 38941| 13.0M| if (inherit == -1 || inherit >= func->def->environments_length) { ------------------ | Branch (38941:21): [True: 12.9M, False: 8.10k] | Branch (38941:38): [True: 0, False: 8.10k] ------------------ 38942| 12.9M| JanetStackFrame *frame = janet_stack_frame(stack); ------------------ | | 854| 12.9M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 12.9M|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 38943| 12.9M| if (!frame->env) { ------------------ | Branch (38943:25): [True: 1.88M, False: 11.1M] ------------------ 38944| | /* Lazy capture of current stack frame */ 38945| 1.88M| JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv)); 38946| 1.88M| env->offset = fiber->frame; 38947| 1.88M| env->as.fiber = fiber; 38948| 1.88M| env->length = func->def->slotcount; 38949| 1.88M| frame->env = env; 38950| 1.88M| } 38951| 12.9M| fn->envs[i] = frame->env; 38952| 12.9M| } else { 38953| 8.10k| fn->envs[i] = func->envs[inherit]; 38954| 8.10k| } 38955| 13.0M| } 38956| 13.0M| } 38957| 13.0M| stack[A] = janet_wrap_function(fn); ------------------ | |37990| 13.0M|#define A ((*pc >> 8) & 0xFF) ------------------ stack[A] = janet_wrap_function(fn); ------------------ | | 852| 13.0M|#define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION) | | ------------------ | | | | 825| 13.0M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 13.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 13.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38958| 13.0M| vm_checkgc_pcnext(); ------------------ | |38045| 13.0M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 13.0M|#define maybe_collect() do {\ | | | |38042| 13.0M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 12.4M, False: 567k] | | | | | Branch (38042:85): [Folded, False: 13.0M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 13.0M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 13.0M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38959| 13.0M| } 38960| | 38961| 32.1M| VM_OP(JOP_PUSH) ------------------ | |38011| 32.1M|#define VM_OP(op) label_##op : ------------------ 38962| 32.1M| janet_fiber_push(fiber, stack[D]); ------------------ | |37993| 32.1M|#define D (*pc >> 8) ------------------ 38963| 32.1M| stack = fiber->data + fiber->frame; 38964| 32.1M| vm_checkgc_pcnext(); ------------------ | |38045| 32.1M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 32.1M|#define maybe_collect() do {\ | | | |38042| 32.1M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 29.6M, False: 2.43M] | | | | | Branch (38042:85): [Folded, False: 32.1M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 32.1M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 32.1M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38965| | 38966| 32.1M| VM_OP(JOP_PUSH_2) ------------------ | |38011| 14.4M|#define VM_OP(op) label_##op : ------------------ 38967| 14.4M| janet_fiber_push2(fiber, stack[A], stack[E]); ------------------ | |37990| 14.4M|#define A ((*pc >> 8) & 0xFF) ------------------ janet_fiber_push2(fiber, stack[A], stack[E]); ------------------ | |37994| 14.4M|#define E (*pc >> 16) ------------------ 38968| 14.4M| stack = fiber->data + fiber->frame; 38969| 14.4M| vm_checkgc_pcnext(); ------------------ | |38045| 14.4M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 14.4M|#define maybe_collect() do {\ | | | |38042| 14.4M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 12.9M, False: 1.49M] | | | | | Branch (38042:85): [Folded, False: 14.4M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 14.4M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 14.4M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38970| | 38971| 14.4M| VM_OP(JOP_PUSH_3) ------------------ | |38011| 12.8M|#define VM_OP(op) label_##op : ------------------ 38972| 12.8M| janet_fiber_push3(fiber, stack[A], stack[B], stack[C]); ------------------ | |37990| 12.8M|#define A ((*pc >> 8) & 0xFF) ------------------ janet_fiber_push3(fiber, stack[A], stack[B], stack[C]); ------------------ | |37991| 12.8M|#define B ((*pc >> 16) & 0xFF) ------------------ janet_fiber_push3(fiber, stack[A], stack[B], stack[C]); ------------------ | |37992| 12.8M|#define C (*pc >> 24) ------------------ 38973| 12.8M| stack = fiber->data + fiber->frame; 38974| 12.8M| vm_checkgc_pcnext(); ------------------ | |38045| 12.8M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 12.8M|#define maybe_collect() do {\ | | | |38042| 12.8M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 11.7M, False: 1.11M] | | | | | Branch (38042:85): [Folded, False: 12.8M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 12.8M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 12.8M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38975| | 38976| 12.8M| VM_OP(JOP_PUSH_ARRAY) { ------------------ | |38011| 2.27M|#define VM_OP(op) label_##op : ------------------ 38977| 2.27M| const Janet *vals; 38978| 2.27M| int32_t len; 38979| 2.27M| if (janet_indexed_view(stack[D], &vals, &len)) { ------------------ | |37993| 2.27M|#define D (*pc >> 8) ------------------ | Branch (38979:13): [True: 2.27M, False: 0] ------------------ 38980| 2.27M| janet_fiber_pushn(fiber, vals, len); 38981| 2.27M| } else { 38982| 0| janet_panicf("expected %T, got %v", JANET_TFLAG_INDEXED, stack[D]); ------------------ | | 613| 0|#define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | ------------------ | | | | 602| 0|#define JANET_TFLAG_ARRAY (1 << JANET_ARRAY) | | ------------------ | | #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE) | | ------------------ | | | | 603| 0|#define JANET_TFLAG_TUPLE (1 << JANET_TUPLE) | | ------------------ ------------------ janet_panicf("expected %T, got %v", JANET_TFLAG_INDEXED, stack[D]); ------------------ | |37993| 0|#define D (*pc >> 8) ------------------ 38983| 0| } 38984| 2.27M| } 38985| 2.27M| stack = fiber->data + fiber->frame; 38986| 2.27M| vm_checkgc_pcnext(); ------------------ | |38045| 2.27M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 2.27M|#define maybe_collect() do {\ | | | |38042| 2.27M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 2.12M, False: 146k] | | | | | Branch (38042:85): [Folded, False: 2.27M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 2.27M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 2.27M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 38987| | 38988| 41.1M| VM_OP(JOP_CALL) { ------------------ | |38011| 41.1M|#define VM_OP(op) label_##op : ------------------ 38989| 41.1M| vm_maybe_auto_suspend(1); ------------------ | |38065| 41.1M|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 41.1M| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 41.1M, Folded] | | | Branch (38066:19): [True: 0, False: 41.1M] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 41.1M|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 41.1M] | | ------------------ ------------------ 38990| 41.1M| Janet callee = stack[E]; ------------------ | |37994| 41.1M|#define E (*pc >> 16) ------------------ 38991| 41.1M| if (fiber->stacktop > fiber->maxstack) { ------------------ | Branch (38991:13): [True: 0, False: 41.1M] ------------------ 38992| 0| vm_throw("stack overflow"); ------------------ | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38048:64): [Folded, False: 0] | | ------------------ ------------------ 38993| 0| } 38994| 41.1M| if (janet_checktype(callee, JANET_KEYWORD)) { ------------------ | | 806| 41.1M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 41.1M] | | | Branch (806:6): [Folded, False: 41.1M] | | ------------------ | | 807| 41.1M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 41.1M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 41.1M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 41.1M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 41.1M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 41.1M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38995| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 38996| 0| callee = resolve_method(callee, fiber); 38997| 0| } 38998| 41.1M| if (janet_checktype(callee, JANET_FUNCTION)) { ------------------ | | 806| 41.1M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 11.0M, False: 30.0M] | | | Branch (806:6): [Folded, False: 41.1M] | | ------------------ | | 807| 41.1M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 41.1M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 41.1M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 41.1M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 41.1M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 41.1M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38999| 11.0M| func = janet_unwrap_function(callee); ------------------ | | 868| 11.0M|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 39000| 11.0M| if (func->gc.flags & JANET_FUNCFLAG_TRACE) { ------------------ | | 1164| 11.0M|#define JANET_FUNCFLAG_TRACE (1 << 16) ------------------ | Branch (39000:17): [True: 0, False: 11.0M] ------------------ 39001| 0| vm_do_trace(func, fiber->stacktop - fiber->stackstart, fiber->data + fiber->stackstart); ------------------ | |38188| 0|#define vm_do_trace(func, argc, argv) do { \ | |38189| 0| JanetFunction* _func = (func);\ | |38190| 0| if (_func->def->name) {\ | | ------------------ | | | Branch (38190:9): [True: 0, False: 0] | | ------------------ | |38191| 0| janet_eprintf("trace (%S", _func->def->name);\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38192| 0| } else {\ | |38193| 0| janet_eprintf("trace (%p", janet_wrap_function(_func));\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38194| 0| }\ | |38195| 0| int32_t _argc = (argc);\ | |38196| 0| for (int32_t i = 0; i < _argc; i++) {\ | | ------------------ | | | Branch (38196:25): [True: 0, False: 0] | | ------------------ | |38197| 0| janet_eprintf(" %p", (argv)[i]);\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38198| 0| }\ | |38199| 0| janet_eprintf(")\n");\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38200| 0|} while (0) | | ------------------ | | | Branch (38200:10): [Folded, False: 0] | | ------------------ ------------------ 39002| 0| } 39003| 11.0M| vm_commit(); ------------------ | |38024| 11.0M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 11.0M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 11.0M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 11.0M] | | ------------------ ------------------ 39004| 11.0M| if (janet_fiber_funcframe(fiber, func)) { ------------------ | Branch (39004:17): [True: 0, False: 11.0M] ------------------ 39005| 0| int32_t n = fiber->stacktop - fiber->stackstart; 39006| 0| janet_panicf("%v called with %d argument%s, expected %d", 39007| 0| callee, n, n == 1 ? "" : "s", func->def->arity); ------------------ | Branch (39007:41): [True: 0, False: 0] ------------------ 39008| 0| } 39009| 11.0M| stack = fiber->data + fiber->frame; 39010| 11.0M| pc = func->def->bytecode; 39011| 11.0M| vm_checkgc_next(); ------------------ | |38043| 11.0M|#define vm_checkgc_next() maybe_collect(); vm_next() | | ------------------ | | | |38041| 11.0M|#define maybe_collect() do {\ | | | |38042| 11.0M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 10.5M, False: 587k] | | | | | Branch (38042:85): [Folded, False: 11.0M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_next() maybe_collect(); vm_next() | | ------------------ | | | |38013| 11.0M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39012| 30.0M| } else if (janet_checktype(callee, JANET_CFUNCTION)) { ------------------ | | 806| 30.0M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 27.1M, False: 2.94M] | | | Branch (806:6): [Folded, False: 30.0M] | | ------------------ | | 807| 30.0M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 30.0M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 30.0M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 30.0M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 30.0M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 30.0M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39013| 27.1M| vm_commit(); ------------------ | |38024| 27.1M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 27.1M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 27.1M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 27.1M] | | ------------------ ------------------ 39014| 27.1M| int32_t argc = fiber->stacktop - fiber->stackstart; 39015| 27.1M| janet_fiber_cframe(fiber, janet_unwrap_cfunction(callee)); ------------------ | | 869| 27.1M|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 39016| 27.1M| Janet ret = janet_unwrap_cfunction(callee)(argc, fiber->data + fiber->frame); ------------------ | | 869| 27.1M|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 39017| 27.1M| janet_fiber_popframe(fiber); 39018| 27.1M| stack = fiber->data + fiber->frame; 39019| 27.1M| stack[A] = ret; ------------------ | |37990| 27.1M|#define A ((*pc >> 8) & 0xFF) ------------------ 39020| 27.1M| vm_checkgc_pcnext(); ------------------ | |38045| 27.1M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 27.1M|#define maybe_collect() do {\ | | | |38042| 27.1M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 24.6M, False: 2.51M] | | | | | Branch (38042:85): [Folded, False: 27.1M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 27.1M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 27.1M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39021| 27.1M| } else { 39022| 2.94M| vm_commit(); ------------------ | |38024| 2.94M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 2.94M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 2.94M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 2.94M] | | ------------------ ------------------ 39023| 2.94M| stack[A] = call_nonfn(fiber, callee); ------------------ | |37990| 2.94M|#define A ((*pc >> 8) & 0xFF) ------------------ 39024| 2.94M| vm_pcnext(); ------------------ | |38044| 2.94M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 2.94M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39025| 2.94M| } 39026| 41.1M| } 39027| | 39028| 41.1M| VM_OP(JOP_TAILCALL) { ------------------ | |38011| 5.09M|#define VM_OP(op) label_##op : ------------------ 39029| 5.09M| vm_maybe_auto_suspend(1); ------------------ | |38065| 5.09M|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 5.09M| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 5.09M, Folded] | | | Branch (38066:19): [True: 0, False: 5.09M] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 5.09M|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 5.09M] | | ------------------ ------------------ 39030| 5.09M| Janet callee = stack[D]; ------------------ | |37993| 5.09M|#define D (*pc >> 8) ------------------ 39031| 5.09M| if (fiber->stacktop > fiber->maxstack) { ------------------ | Branch (39031:13): [True: 0, False: 5.09M] ------------------ 39032| 0| vm_throw("stack overflow"); ------------------ | |38048| 0|#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0) | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (38048:64): [Folded, False: 0] | | ------------------ ------------------ 39033| 0| } 39034| 5.09M| if (janet_checktype(callee, JANET_KEYWORD)) { ------------------ | | 806| 5.09M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 0, False: 5.09M] | | | Branch (806:6): [Folded, False: 5.09M] | | ------------------ | | 807| 5.09M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.09M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.09M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.09M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.09M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.09M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39035| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39036| 0| callee = resolve_method(callee, fiber); 39037| 0| } 39038| 5.09M| if (janet_checktype(callee, JANET_FUNCTION)) { ------------------ | | 806| 5.09M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 3.83M, False: 1.25M] | | | Branch (806:6): [Folded, False: 5.09M] | | ------------------ | | 807| 5.09M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 5.09M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 5.09M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 5.09M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 5.09M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 5.09M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39039| 3.83M| func = janet_unwrap_function(callee); ------------------ | | 868| 3.83M|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 39040| 3.83M| if (func->gc.flags & JANET_FUNCFLAG_TRACE) { ------------------ | | 1164| 3.83M|#define JANET_FUNCFLAG_TRACE (1 << 16) ------------------ | Branch (39040:17): [True: 0, False: 3.83M] ------------------ 39041| 0| vm_do_trace(func, fiber->stacktop - fiber->stackstart, fiber->data + fiber->stackstart); ------------------ | |38188| 0|#define vm_do_trace(func, argc, argv) do { \ | |38189| 0| JanetFunction* _func = (func);\ | |38190| 0| if (_func->def->name) {\ | | ------------------ | | | Branch (38190:9): [True: 0, False: 0] | | ------------------ | |38191| 0| janet_eprintf("trace (%S", _func->def->name);\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38192| 0| } else {\ | |38193| 0| janet_eprintf("trace (%p", janet_wrap_function(_func));\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38194| 0| }\ | |38195| 0| int32_t _argc = (argc);\ | |38196| 0| for (int32_t i = 0; i < _argc; i++) {\ | | ------------------ | | | Branch (38196:25): [True: 0, False: 0] | | ------------------ | |38197| 0| janet_eprintf(" %p", (argv)[i]);\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38198| 0| }\ | |38199| 0| janet_eprintf(")\n");\ | | ------------------ | | | | 2195| 0|#define janet_eprintf(...) janet_dynprintf("err", stderr, __VA_ARGS__) | | ------------------ | |38200| 0|} while (0) | | ------------------ | | | Branch (38200:10): [Folded, False: 0] | | ------------------ ------------------ 39042| 0| } 39043| 3.83M| if (janet_fiber_funcframe_tail(fiber, func)) { ------------------ | Branch (39043:17): [True: 229, False: 3.83M] ------------------ 39044| 229| janet_stack_frame(fiber->data + fiber->frame)->pc = pc; ------------------ | | 854| 229|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 229|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 39045| 229| int32_t n = fiber->stacktop - fiber->stackstart; 39046| 229| janet_panicf("%v called with %d argument%s, expected %d", 39047| 229| callee, n, n == 1 ? "" : "s", func->def->arity); ------------------ | Branch (39047:41): [True: 0, False: 229] ------------------ 39048| 229| } 39049| 3.83M| stack = fiber->data + fiber->frame; 39050| 3.83M| pc = func->def->bytecode; 39051| 3.83M| vm_checkgc_next(); ------------------ | |38043| 3.83M|#define vm_checkgc_next() maybe_collect(); vm_next() | | ------------------ | | | |38041| 3.83M|#define maybe_collect() do {\ | | | |38042| 3.83M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 3.60M, False: 225k] | | | | | Branch (38042:85): [Folded, False: 3.83M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_next() maybe_collect(); vm_next() | | ------------------ | | | |38013| 3.83M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39052| 3.83M| } else { 39053| 1.25M| Janet retreg; 39054| 1.25M| int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 854| 1.25M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 1.25M|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE; ------------------ | | 1013| 1.25M|#define JANET_STACKFRAME_ENTRANCE 2 ------------------ 39055| 1.25M| vm_commit(); ------------------ | |38024| 1.25M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 1.25M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 1.25M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 1.25M] | | ------------------ ------------------ 39056| 1.25M| if (janet_checktype(callee, JANET_CFUNCTION)) { ------------------ | | 806| 1.25M| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:5): [True: 1.25M, False: 0] | | | Branch (806:6): [Folded, False: 1.25M] | | ------------------ | | 807| 1.25M| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 1.25M| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 1.25M| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 1.25M|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 1.25M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.25M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39057| 1.25M| int32_t argc = fiber->stacktop - fiber->stackstart; 39058| 1.25M| janet_fiber_cframe(fiber, janet_unwrap_cfunction(callee)); ------------------ | | 869| 1.25M|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 39059| 1.25M| retreg = janet_unwrap_cfunction(callee)(argc, fiber->data + fiber->frame); ------------------ | | 869| 1.25M|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 39060| 1.25M| janet_fiber_popframe(fiber); 39061| 1.25M| } else { 39062| 0| retreg = call_nonfn(fiber, callee); 39063| 0| } 39064| 1.25M| janet_fiber_popframe(fiber); 39065| 1.25M| if (entrance_frame) { ------------------ | Branch (39065:17): [True: 512, False: 1.25M] ------------------ 39066| 512| vm_return_no_restore(JANET_SIGNAL_OK, retreg); ------------------ | |38035| 512|#define vm_return_no_restore(sig, val) do { \ | |38036| 512| janet_vm.return_reg[0] = (val); \ | |38037| 512| return (sig); \ | |38038| 512|} while (0) | | ------------------ | | | Branch (38038:10): [Folded, False: 0] | | ------------------ ------------------ 39067| 512| } 39068| 1.25M| vm_restore(); ------------------ | |38025| 1.25M|#define vm_restore() do { \ | |38026| 1.25M| stack = fiber->data + fiber->frame; \ | |38027| 1.25M| pc = janet_stack_frame(stack)->pc; \ | | ------------------ | | | | 854| 1.25M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 1.25M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38028| 1.25M| func = janet_stack_frame(stack)->func; \ | | ------------------ | | | | 854| 1.25M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 1.25M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | |38029| 1.25M|} while (0) | | ------------------ | | | Branch (38029:10): [Folded, False: 1.25M] | | ------------------ ------------------ 39069| 1.25M| stack[A] = retreg; ------------------ | |37990| 1.25M|#define A ((*pc >> 8) & 0xFF) ------------------ 39070| 1.25M| vm_checkgc_pcnext(); ------------------ | |38045| 1.25M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 1.25M|#define maybe_collect() do {\ | | | |38042| 1.25M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 1.17M, False: 79.1k] | | | | | Branch (38042:85): [Folded, False: 1.25M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 1.25M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 1.25M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39071| 1.25M| } 39072| 5.09M| } 39073| | 39074| 5.09M| VM_OP(JOP_RESUME) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39075| 0| Janet retreg; 39076| 0| vm_maybe_auto_suspend(1); ------------------ | |38065| 0|#define vm_maybe_auto_suspend(COND) do { \ | |38066| 0| if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \ | | ------------------ | | | Branch (38066:9): [True: 0, Folded] | | | Branch (38066:19): [True: 0, False: 0] | | ------------------ | |38067| 0| fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 | | ------------------ | | fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \ | | ------------------ | | | | 836| 0|#define JANET_FIBER_RESUME_NO_SKIP 0x4000000 | | ------------------ | |38068| 0| vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \ | | ------------------ | | | |38030| 0|#define vm_return(sig, val) do { \ | | | |38031| 0| janet_vm.return_reg[0] = (val); \ | | | |38032| 0| vm_commit(); \ | | | | ------------------ | | | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | | | ------------------ | | | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | | | ------------------ | | | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (38024:70): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | |38033| 0| return (sig); \ | | | |38034| 0|} while (0) | | | | ------------------ | | | | | Branch (38034:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38069| 0| } \ | |38070| 0|} while (0) | | ------------------ | | | Branch (38070:10): [Folded, False: 0] | | ------------------ ------------------ 39077| 0| vm_assert_type(stack[B], JANET_FIBER); ------------------ | |38050| 0|#define vm_assert_type(X, T) do { \ | |38051| 0| if (!(janet_checktype((X), (T)))) { \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38051:9): [True: 0, False: 0] | | ------------------ | |38052| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38053| 0| janet_panicf("expected %T, got %v", (1 << (T)), (X)); \ | |38054| 0| } \ | |38055| 0|} while (0) | | ------------------ | | | Branch (38055:10): [Folded, False: 0] | | ------------------ ------------------ 39078| 0| JanetFiber *child = janet_unwrap_fiber(stack[B]); ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 39079| 0| if (janet_check_can_resume(child, &retreg, 0)) { ------------------ | Branch (39079:13): [True: 0, False: 0] ------------------ 39080| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39081| 0| janet_panicv(retreg); 39082| 0| } 39083| 0| fiber->child = child; 39084| 0| JanetSignal sig = janet_continue_no_check(child, stack[C], &retreg); ------------------ | |37992| 0|#define C (*pc >> 24) ------------------ 39085| 0| stack = fiber->data + fiber->frame; 39086| 0| if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { ------------------ | Branch (39086:13): [True: 0, False: 0] | Branch (39086:39): [True: 0, False: 0] ------------------ 39087| 0| vm_return(sig, retreg); ------------------ | |38030| 0|#define vm_return(sig, val) do { \ | |38031| 0| janet_vm.return_reg[0] = (val); \ | |38032| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38033| 0| return (sig); \ | |38034| 0|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 39088| 0| } 39089| 0| fiber->child = NULL; 39090| 0| stack[A] = retreg; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 39091| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39092| 0| } 39093| | 39094| 0| VM_OP(JOP_SIGNAL) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39095| 0| int32_t s = C; ------------------ | |37992| 0|#define C (*pc >> 24) ------------------ 39096| 0| if (s > JANET_SIGNAL_USER9) s = JANET_SIGNAL_USER9; ------------------ | Branch (39096:13): [True: 0, False: 0] ------------------ 39097| 0| if (s < 0) s = 0; ------------------ | Branch (39097:13): [True: 0, False: 0] ------------------ 39098| 0| vm_return(s, stack[B]); ------------------ | |38030| 0|#define vm_return(sig, val) do { \ | |38031| 0| janet_vm.return_reg[0] = (val); \ | |38032| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38033| 0| return (sig); \ | |38034| 0|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 39099| 0| } 39100| | 39101| 0| VM_OP(JOP_PROPAGATE) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39102| 0| Janet fv = stack[C]; ------------------ | |37992| 0|#define C (*pc >> 24) ------------------ 39103| 0| vm_assert_type(fv, JANET_FIBER); ------------------ | |38050| 0|#define vm_assert_type(X, T) do { \ | |38051| 0| if (!(janet_checktype((X), (T)))) { \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38051:9): [True: 0, False: 0] | | ------------------ | |38052| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38053| 0| janet_panicf("expected %T, got %v", (1 << (T)), (X)); \ | |38054| 0| } \ | |38055| 0|} while (0) | | ------------------ | | | Branch (38055:10): [Folded, False: 0] | | ------------------ ------------------ 39104| 0| JanetFiber *f = janet_unwrap_fiber(fv); ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 39105| 0| JanetFiberStatus sub_status = janet_fiber_status(f); 39106| 0| if (sub_status > JANET_STATUS_USER9) { ------------------ | Branch (39106:13): [True: 0, False: 0] ------------------ 39107| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39108| 0| janet_panicf("cannot propagate from fiber with status :%s", 39109| 0| janet_status_names[sub_status]); 39110| 0| } 39111| 0| fiber->child = f; 39112| 0| vm_return((int) sub_status, stack[B]); ------------------ | |38030| 0|#define vm_return(sig, val) do { \ | |38031| 0| janet_vm.return_reg[0] = (val); \ | |38032| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38033| 0| return (sig); \ | |38034| 0|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 39113| 0| } 39114| | 39115| 0| VM_OP(JOP_CANCEL) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39116| 0| Janet retreg; 39117| 0| vm_assert_type(stack[B], JANET_FIBER); ------------------ | |38050| 0|#define vm_assert_type(X, T) do { \ | |38051| 0| if (!(janet_checktype((X), (T)))) { \ | | ------------------ | | | | 806| 0| (((t) == JANET_NUMBER) \ | | | | ------------------ | | | | | Branch (806:6): [Folded, False: 0] | | | | ------------------ | | | | 807| 0| ? janet_nanbox_isnumber(x) \ | | | | ------------------ | | | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | | | ------------------ | | | | | | | Branch (803:6): [True: 0, False: 0] | | | | | | | Branch (803:28): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 808| 0| : janet_nanbox_checkauxtype((x), (t))) | | | | ------------------ | | | | | | 800| 0| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 790| 0|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | | | ------------------ | | | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (38051:9): [True: 0, False: 0] | | ------------------ | |38052| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38053| 0| janet_panicf("expected %T, got %v", (1 << (T)), (X)); \ | |38054| 0| } \ | |38055| 0|} while (0) | | ------------------ | | | Branch (38055:10): [Folded, False: 0] | | ------------------ ------------------ 39118| 0| JanetFiber *child = janet_unwrap_fiber(stack[B]); ------------------ | | 859| 0|#define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x)) ------------------ 39119| 0| if (janet_check_can_resume(child, &retreg, 1)) { ------------------ | Branch (39119:13): [True: 0, False: 0] ------------------ 39120| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39121| 0| janet_panicv(retreg); 39122| 0| } 39123| 0| fiber->child = child; 39124| 0| JanetSignal sig = janet_continue_signal(child, stack[C], &retreg, JANET_SIGNAL_ERROR); ------------------ | |37992| 0|#define C (*pc >> 24) ------------------ 39125| 0| if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { ------------------ | Branch (39125:13): [True: 0, False: 0] | Branch (39125:39): [True: 0, False: 0] ------------------ 39126| 0| vm_return(sig, retreg); ------------------ | |38030| 0|#define vm_return(sig, val) do { \ | |38031| 0| janet_vm.return_reg[0] = (val); \ | |38032| 0| vm_commit(); \ | | ------------------ | | | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | | | ------------------ | | | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | | | ------------------ | | | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (38024:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | |38033| 0| return (sig); \ | |38034| 0|} while (0) | | ------------------ | | | Branch (38034:10): [Folded, False: 0] | | ------------------ ------------------ 39127| 0| } 39128| 0| fiber->child = NULL; 39129| 0| stack = fiber->data + fiber->frame; 39130| 0| stack[A] = retreg; ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ 39131| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39132| 0| } 39133| | 39134| 17.8k| VM_OP(JOP_PUT) ------------------ | |38011| 17.8k|#define VM_OP(op) label_##op : ------------------ 39135| 17.8k| vm_commit(); ------------------ | |38024| 17.8k|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 17.8k|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 17.8k|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 17.8k] | | ------------------ ------------------ 39136| 17.8k| fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL; ------------------ | | 835| 17.8k|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ 39137| 17.8k| janet_put(stack[A], stack[B], stack[C]); ------------------ | |37990| 17.8k|#define A ((*pc >> 8) & 0xFF) ------------------ janet_put(stack[A], stack[B], stack[C]); ------------------ | |37991| 17.8k|#define B ((*pc >> 16) & 0xFF) ------------------ janet_put(stack[A], stack[B], stack[C]); ------------------ | |37992| 17.8k|#define C (*pc >> 24) ------------------ 39138| 17.8k| stack = fiber->data + fiber->frame; 39139| 17.8k| fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL; ------------------ | | 835| 17.8k|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ 39140| 17.8k| vm_checkgc_pcnext(); ------------------ | |38045| 17.8k|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 17.8k|#define maybe_collect() do {\ | | | |38042| 17.8k| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 1.22k, False: 16.5k] | | | | | Branch (38042:85): [Folded, False: 17.8k] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 17.8k|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 17.8k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39141| | 39142| 17.8k| VM_OP(JOP_PUT_INDEX) ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39143| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39144| 0| fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL; ------------------ | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ 39145| 0| janet_putindex(stack[A], C, stack[B]); ------------------ | |37990| 0|#define A ((*pc >> 8) & 0xFF) ------------------ janet_putindex(stack[A], C, stack[B]); ------------------ | |37992| 0|#define C (*pc >> 24) ------------------ janet_putindex(stack[A], C, stack[B]); ------------------ | |37991| 0|#define B ((*pc >> 16) & 0xFF) ------------------ 39146| 0| stack = fiber->data + fiber->frame; 39147| 0| fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL; ------------------ | | 835| 0|#define JANET_FIBER_RESUME_NO_USEVAL 0x2000000 ------------------ 39148| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39149| | 39150| 12.5M| VM_OP(JOP_IN) ------------------ | |38011| 12.5M|#define VM_OP(op) label_##op : ------------------ 39151| 12.5M| vm_commit(); ------------------ | |38024| 12.5M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 12.5M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 12.5M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 12.5M] | | ------------------ ------------------ 39152| 12.5M| { 39153| 12.5M| Janet a = janet_in(stack[B], stack[C]); ------------------ | |37991| 12.5M|#define B ((*pc >> 16) & 0xFF) ------------------ Janet a = janet_in(stack[B], stack[C]); ------------------ | |37992| 12.5M|#define C (*pc >> 24) ------------------ 39154| 12.5M| stack = fiber->data + fiber->frame; 39155| 12.5M| stack[A] = a; ------------------ | |37990| 12.5M|#define A ((*pc >> 8) & 0xFF) ------------------ 39156| 12.5M| } 39157| 12.5M| vm_pcnext(); ------------------ | |38044| 12.5M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 12.5M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39158| | 39159| 12.5M| VM_OP(JOP_GET) ------------------ | |38011| 1.71M|#define VM_OP(op) label_##op : ------------------ 39160| 1.71M| vm_commit(); ------------------ | |38024| 1.71M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 1.71M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 1.71M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 1.71M] | | ------------------ ------------------ 39161| 1.71M| { 39162| 1.71M| Janet a = janet_get(stack[B], stack[C]); ------------------ | |37991| 1.71M|#define B ((*pc >> 16) & 0xFF) ------------------ Janet a = janet_get(stack[B], stack[C]); ------------------ | |37992| 1.71M|#define C (*pc >> 24) ------------------ 39163| 1.71M| stack = fiber->data + fiber->frame; 39164| 1.71M| stack[A] = a; ------------------ | |37990| 1.71M|#define A ((*pc >> 8) & 0xFF) ------------------ 39165| 1.71M| } 39166| 1.71M| vm_pcnext(); ------------------ | |38044| 1.71M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 1.71M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39167| | 39168| 1.71M| VM_OP(JOP_GET_INDEX) ------------------ | |38011| 64.4k|#define VM_OP(op) label_##op : ------------------ 39169| 64.4k| vm_commit(); ------------------ | |38024| 64.4k|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 64.4k|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 64.4k|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 64.4k] | | ------------------ ------------------ 39170| 64.4k| { 39171| 64.4k| Janet a = janet_getindex(stack[B], C); ------------------ | |37991| 64.4k|#define B ((*pc >> 16) & 0xFF) ------------------ Janet a = janet_getindex(stack[B], C); ------------------ | |37992| 64.4k|#define C (*pc >> 24) ------------------ 39172| 64.4k| stack = fiber->data + fiber->frame; 39173| 64.4k| stack[A] = a; ------------------ | |37990| 64.4k|#define A ((*pc >> 8) & 0xFF) ------------------ 39174| 64.4k| } 39175| 64.4k| vm_pcnext(); ------------------ | |38044| 64.4k|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 64.4k|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39176| | 39177| 5.54M| VM_OP(JOP_LENGTH) ------------------ | |38011| 5.54M|#define VM_OP(op) label_##op : ------------------ 39178| 5.54M| vm_commit(); ------------------ | |38024| 5.54M|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 5.54M|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 5.54M|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 5.54M] | | ------------------ ------------------ 39179| 5.54M| { 39180| 5.54M| Janet a = janet_lengthv(stack[E]); ------------------ | |37994| 5.54M|#define E (*pc >> 16) ------------------ 39181| 5.54M| stack = fiber->data + fiber->frame; 39182| 5.54M| stack[A] = a; ------------------ | |37990| 5.54M|#define A ((*pc >> 8) & 0xFF) ------------------ 39183| 5.54M| } 39184| 5.54M| vm_pcnext(); ------------------ | |38044| 5.54M|#define vm_pcnext() pc++; vm_next() | | ------------------ | | | |38013| 5.54M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | ------------------ ------------------ 39185| | 39186| 5.54M| VM_OP(JOP_MAKE_ARRAY) { ------------------ | |38011| 1.32M|#define VM_OP(op) label_##op : ------------------ 39187| 1.32M| int32_t count = fiber->stacktop - fiber->stackstart; 39188| 1.32M| Janet *mem = fiber->data + fiber->stackstart; 39189| 1.32M| stack[D] = janet_wrap_array(janet_array_n(mem, count)); ------------------ | |37993| 1.32M|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_array(janet_array_n(mem, count)); ------------------ | | 845| 1.32M|#define janet_wrap_array(s) janet_nanbox_wrap_((s), JANET_ARRAY) | | ------------------ | | | | 825| 1.32M| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.32M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.32M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39190| 1.32M| fiber->stacktop = fiber->stackstart; 39191| 1.32M| vm_checkgc_pcnext(); ------------------ | |38045| 1.32M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 1.32M|#define maybe_collect() do {\ | | | |38042| 1.32M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 1.20M, False: 113k] | | | | | Branch (38042:85): [Folded, False: 1.32M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 1.32M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 1.32M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39192| 1.32M| } 39193| | 39194| 1.68M| VM_OP(JOP_MAKE_TUPLE) ------------------ | |38011| 1.68M|#define VM_OP(op) label_##op : ------------------ 39195| | /* fallthrough */ 39196| 1.83M| VM_OP(JOP_MAKE_BRACKET_TUPLE) { ------------------ | |38011| 1.83M|#define VM_OP(op) label_##op : ------------------ 39197| 1.83M| int32_t count = fiber->stacktop - fiber->stackstart; 39198| 1.83M| Janet *mem = fiber->data + fiber->stackstart; 39199| 1.83M| const Janet *tup = janet_tuple_n(mem, count); 39200| 1.83M| if (opcode == JOP_MAKE_BRACKET_TUPLE) ------------------ | |38014| 1.83M|#define opcode (*pc & 0xFF) ------------------ | Branch (39200:13): [True: 156k, False: 1.68M] ------------------ 39201| 156k| janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1806| 156k|#define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags) | | ------------------ | | | | 1800| 156k|#define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data))) | | ------------------ ------------------ janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR; ------------------ | | 1798| 156k|#define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000 ------------------ 39202| 1.83M| stack[D] = janet_wrap_tuple(tup); ------------------ | |37993| 1.83M|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_tuple(tup); ------------------ | | 843| 1.83M|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 1.83M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.83M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.83M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39203| 1.83M| fiber->stacktop = fiber->stackstart; 39204| 1.83M| vm_checkgc_pcnext(); ------------------ | |38045| 1.83M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 1.83M|#define maybe_collect() do {\ | | | |38042| 1.83M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 1.38M, False: 455k] | | | | | Branch (38042:85): [Folded, False: 1.83M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 1.83M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 1.83M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39205| 1.83M| } 39206| | 39207| 1.83M| VM_OP(JOP_MAKE_TABLE) { ------------------ | |38011| 921|#define VM_OP(op) label_##op : ------------------ 39208| 921| int32_t count = fiber->stacktop - fiber->stackstart; 39209| 921| Janet *mem = fiber->data + fiber->stackstart; 39210| 921| if (count & 1) { ------------------ | Branch (39210:13): [True: 0, False: 921] ------------------ 39211| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39212| 0| janet_panicf("expected even number of arguments to table constructor, got %d", count); 39213| 0| } 39214| 921| JanetTable *table = janet_table(count / 2); 39215| 921| for (int32_t i = 0; i < count; i += 2) ------------------ | Branch (39215:29): [True: 0, False: 921] ------------------ 39216| 0| janet_table_put(table, mem[i], mem[i + 1]); 39217| 921| stack[D] = janet_wrap_table(table); ------------------ | |37993| 921|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_table(table); ------------------ | | 846| 921|#define janet_wrap_table(s) janet_nanbox_wrap_((s), JANET_TABLE) | | ------------------ | | | | 825| 921| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 921|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 921|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39218| 921| fiber->stacktop = fiber->stackstart; 39219| 921| vm_checkgc_pcnext(); ------------------ | |38045| 921|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 921|#define maybe_collect() do {\ | | | |38042| 921| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 684, False: 237] | | | | | Branch (38042:85): [Folded, False: 921] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 921|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 921|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39220| 921| } 39221| | 39222| 1.53M| VM_OP(JOP_MAKE_STRUCT) { ------------------ | |38011| 1.53M|#define VM_OP(op) label_##op : ------------------ 39223| 1.53M| int32_t count = fiber->stacktop - fiber->stackstart; 39224| 1.53M| Janet *mem = fiber->data + fiber->stackstart; 39225| 1.53M| if (count & 1) { ------------------ | Branch (39225:13): [True: 0, False: 1.53M] ------------------ 39226| 0| vm_commit(); ------------------ | |38024| 0|#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0) | | ------------------ | | | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | | | ------------------ | | | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | | | ------------------ | | ------------------ | | | Branch (38024:70): [Folded, False: 0] | | ------------------ ------------------ 39227| 0| janet_panicf("expected even number of arguments to struct constructor, got %d", count); 39228| 0| } 39229| 1.53M| JanetKV *st = janet_struct_begin(count / 2); 39230| 18.4M| for (int32_t i = 0; i < count; i += 2) ------------------ | Branch (39230:29): [True: 16.9M, False: 1.53M] ------------------ 39231| 16.9M| janet_struct_put(st, mem[i], mem[i + 1]); 39232| 1.53M| stack[D] = janet_wrap_struct(janet_struct_end(st)); ------------------ | |37993| 1.53M|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_struct(janet_struct_end(st)); ------------------ | | 842| 1.53M|#define janet_wrap_struct(s) janet_nanbox_wrap_c((s), JANET_STRUCT) | | ------------------ | | | | 828| 1.53M| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 1.53M|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 1.53M|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39233| 1.53M| fiber->stacktop = fiber->stackstart; 39234| 1.53M| vm_checkgc_pcnext(); ------------------ | |38045| 1.53M|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 1.53M|#define maybe_collect() do {\ | | | |38042| 1.53M| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 1.47M, False: 66.1k] | | | | | Branch (38042:85): [Folded, False: 1.53M] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 1.53M|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 1.53M|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39235| 1.53M| } 39236| | 39237| 0| VM_OP(JOP_MAKE_STRING) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39238| 0| int32_t count = fiber->stacktop - fiber->stackstart; 39239| 0| Janet *mem = fiber->data + fiber->stackstart; 39240| 0| JanetBuffer buffer; 39241| 0| janet_buffer_init(&buffer, 10 * count); 39242| 0| for (int32_t i = 0; i < count; i++) ------------------ | Branch (39242:29): [True: 0, False: 0] ------------------ 39243| 0| janet_to_string_b(&buffer, mem[i]); 39244| 0| stack[D] = janet_stringv(buffer.data, buffer.count); ------------------ | |37993| 0|#define D (*pc >> 8) ------------------ stack[D] = janet_stringv(buffer.data, buffer.count); ------------------ | | 1827| 0|#define janet_stringv(str, len) janet_wrap_string(janet_string((str), (len))) | | ------------------ | | | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39245| 0| janet_buffer_deinit(&buffer); 39246| 0| fiber->stacktop = fiber->stackstart; 39247| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39248| 0| } 39249| | 39250| 0| VM_OP(JOP_MAKE_BUFFER) { ------------------ | |38011| 0|#define VM_OP(op) label_##op : ------------------ 39251| 0| int32_t count = fiber->stacktop - fiber->stackstart; 39252| 0| Janet *mem = fiber->data + fiber->stackstart; 39253| 0| JanetBuffer *buffer = janet_buffer(10 * count); 39254| 0| for (int32_t i = 0; i < count; i++) ------------------ | Branch (39254:29): [True: 0, False: 0] ------------------ 39255| 0| janet_to_string_b(buffer, mem[i]); 39256| 0| stack[D] = janet_wrap_buffer(buffer); ------------------ | |37993| 0|#define D (*pc >> 8) ------------------ stack[D] = janet_wrap_buffer(buffer); ------------------ | | 847| 0|#define janet_wrap_buffer(s) janet_nanbox_wrap_((s), JANET_BUFFER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39257| 0| fiber->stacktop = fiber->stackstart; 39258| 0| vm_checkgc_pcnext(); ------------------ | |38045| 0|#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38041| 0|#define maybe_collect() do {\ | | | |38042| 0| if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0) | | | | ------------------ | | | | | Branch (38042:9): [True: 0, False: 0] | | | | | Branch (38042:85): [Folded, False: 0] | | | | ------------------ | | ------------------ | | #define vm_checkgc_pcnext() maybe_collect(); vm_pcnext() | | ------------------ | | | |38044| 0|#define vm_pcnext() pc++; vm_next() | | | | ------------------ | | | | | |38013| 0|#define vm_next() goto *op_lookup[*pc & 0xFF] | | | | ------------------ | | ------------------ ------------------ 39259| 0| } 39260| | 39261| 0| VM_END() ------------------ | |38010| 0|#define VM_END() } ------------------ 39262| 0|} janet.c:method_to_fun: 38248| 132|static Janet method_to_fun(Janet method, Janet obj) { 38249| 132| return janet_get(obj, method); 38250| 132|} janet.c:call_nonfn: 38241| 2.94M|static Janet call_nonfn(JanetFiber *fiber, Janet callee) { 38242| 2.94M| int32_t argc = fiber->stacktop - fiber->stackstart; 38243| 2.94M| fiber->stacktop = fiber->stackstart; 38244| 2.94M| return janet_method_invoke(callee, argc, fiber->data + fiber->stacktop); 38245| 2.94M|} janet.c:janet_check_can_resume: 39401| 68.6k|static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out, int is_cancel) { 39402| | /* Check conditions */ 39403| 68.6k| JanetFiberStatus old_status = janet_fiber_status(fiber); 39404| 68.6k| if (janet_vm.stackn >= JANET_RECURSION_GUARD) { ------------------ | | 296| 68.6k|#define JANET_RECURSION_GUARD 1024 ------------------ | Branch (39404:9): [True: 0, False: 68.6k] ------------------ 39405| 0| janet_fiber_set_status(fiber, JANET_STATUS_ERROR); ------------------ | | 849| 0|#define janet_fiber_set_status(f, s) do {\ | | 850| 0| (f)->flags &= ~JANET_FIBER_STATUS_MASK;\ | | ------------------ | | | | 830| 0|#define JANET_FIBER_STATUS_MASK 0x3F0000 | | ------------------ | | 851| 0| (f)->flags |= (s) << JANET_FIBER_STATUS_OFFSET;\ | | ------------------ | | | | 832| 0|#define JANET_FIBER_STATUS_OFFSET 16 | | ------------------ | | 852| 0|} while (0) | | ------------------ | | | Branch (852:10): [Folded, False: 0] | | ------------------ ------------------ 39406| 0| *out = janet_cstringv("C stack recursed too deeply"); ------------------ | | 1826| 0|#define janet_cstringv(cstr) janet_wrap_string(janet_cstring(cstr)) | | ------------------ | | | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39407| 0| return JANET_SIGNAL_ERROR; 39408| 0| } 39409| | /* If a "task" fiber is trying to be used as a normal fiber, detect that. See bug #920. 39410| | * Fibers must be marked as root fibers manually, or by the ev scheduler. */ 39411| 68.6k| if (janet_vm.fiber != NULL && (fiber->gc.flags & JANET_FIBER_EV_GCFLAG_ROOT)) { ------------------ | | 844| 0|#define JANET_FIBER_EV_GCFLAG_ROOT 0x4000000 ------------------ | Branch (39411:9): [True: 0, False: 68.6k] | Branch (39411:35): [True: 0, False: 0] ------------------ 39412| 0|#ifdef JANET_EV 39413| 0| *out = janet_cstringv(is_cancel ------------------ | | 1826| 0|#define janet_cstringv(cstr) janet_wrap_string(janet_cstring(cstr)) | | ------------------ | | | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | | | ------------------ | | | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (828:33): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39414| 0| ? "cannot cancel root fiber, use ev/cancel" 39415| 0| : "cannot resume root fiber, use ev/go"); 39416| |#else 39417| | *out = janet_cstringv(is_cancel 39418| | ? "cannot cancel root fiber" 39419| | : "cannot resume root fiber"); 39420| |#endif 39421| 0| return JANET_SIGNAL_ERROR; 39422| 0| } 39423| 68.6k| if (old_status == JANET_STATUS_ALIVE || ------------------ | Branch (39423:9): [True: 0, False: 68.6k] ------------------ 39424| 68.6k| old_status == JANET_STATUS_DEAD || ------------------ | Branch (39424:13): [True: 0, False: 68.6k] ------------------ 39425| 68.6k| (old_status >= JANET_STATUS_USER0 && old_status <= JANET_STATUS_USER4) || ------------------ | Branch (39425:14): [True: 68.6k, False: 0] | Branch (39425:50): [True: 0, False: 68.6k] ------------------ 39426| 68.6k| old_status == JANET_STATUS_ERROR) { ------------------ | Branch (39426:13): [True: 0, False: 68.6k] ------------------ 39427| 0| const uint8_t *str = janet_formatc("cannot resume fiber with status :%s", 39428| 0| janet_status_names[old_status]); 39429| 0| *out = janet_wrap_string(str); ------------------ | | 848| 0|#define janet_wrap_string(s) janet_nanbox_wrap_c((s), JANET_STRING) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39430| 0| return JANET_SIGNAL_ERROR; 39431| 0| } 39432| 68.6k| return JANET_SIGNAL_OK; 39433| 68.6k|} janet.c:janet_continue_no_check: 39456| 68.6k|static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out) { 39457| | 39458| 68.6k| JanetFiberStatus old_status = janet_fiber_status(fiber); 39459| | 39460| 68.6k|#ifdef JANET_EV 39461| 68.6k| janet_fiber_did_resume(fiber); 39462| 68.6k|#endif 39463| | 39464| | /* Clear last value */ 39465| 68.6k| fiber->last_value = janet_wrap_nil(); ------------------ | | 831| 68.6k|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 68.6k| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39466| | 39467| | /* Continue child fiber if it exists */ 39468| 68.6k| if (fiber->child) { ------------------ | Branch (39468:9): [True: 0, False: 68.6k] ------------------ 39469| 0| if (janet_vm.root_fiber == NULL) janet_vm.root_fiber = fiber; ------------------ | Branch (39469:13): [True: 0, False: 0] ------------------ 39470| 0| JanetFiber *child = fiber->child; 39471| 0| uint32_t instr = (janet_stack_frame(fiber->data + fiber->frame)->pc)[0]; ------------------ | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 39472| 0| janet_vm.stackn++; 39473| 0| JanetSignal sig = janet_continue(child, in, &in); 39474| 0| janet_vm.stackn--; 39475| 0| if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL; ------------------ | Branch (39475:13): [True: 0, False: 0] ------------------ 39476| 0| if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) { ------------------ | Branch (39476:13): [True: 0, False: 0] | Branch (39476:39): [True: 0, False: 0] ------------------ 39477| 0| *out = in; 39478| 0| janet_fiber_set_status(fiber, sig); ------------------ | | 849| 0|#define janet_fiber_set_status(f, s) do {\ | | 850| 0| (f)->flags &= ~JANET_FIBER_STATUS_MASK;\ | | ------------------ | | | | 830| 0|#define JANET_FIBER_STATUS_MASK 0x3F0000 | | ------------------ | | 851| 0| (f)->flags |= (s) << JANET_FIBER_STATUS_OFFSET;\ | | ------------------ | | | | 832| 0|#define JANET_FIBER_STATUS_OFFSET 16 | | ------------------ | | 852| 0|} while (0) | | ------------------ | | | Branch (852:10): [Folded, False: 0] | | ------------------ ------------------ 39479| 0| fiber->last_value = child->last_value; 39480| 0| return sig; 39481| 0| } 39482| | /* Check if we need any special handling for certain opcodes */ 39483| 0| switch (instr & 0x7F) { 39484| 0| default: ------------------ | Branch (39484:13): [True: 0, False: 0] ------------------ 39485| 0| break; 39486| 0| case JOP_NEXT: { ------------------ | Branch (39486:13): [True: 0, False: 0] ------------------ 39487| 0| if (sig == JANET_SIGNAL_OK || ------------------ | Branch (39487:21): [True: 0, False: 0] ------------------ 39488| 0| sig == JANET_SIGNAL_ERROR || ------------------ | Branch (39488:25): [True: 0, False: 0] ------------------ 39489| 0| sig == JANET_SIGNAL_USER0 || ------------------ | Branch (39489:25): [True: 0, False: 0] ------------------ 39490| 0| sig == JANET_SIGNAL_USER1 || ------------------ | Branch (39490:25): [True: 0, False: 0] ------------------ 39491| 0| sig == JANET_SIGNAL_USER2 || ------------------ | Branch (39491:25): [True: 0, False: 0] ------------------ 39492| 0| sig == JANET_SIGNAL_USER3 || ------------------ | Branch (39492:25): [True: 0, False: 0] ------------------ 39493| 0| sig == JANET_SIGNAL_USER4) { ------------------ | Branch (39493:25): [True: 0, False: 0] ------------------ 39494| 0| in = janet_wrap_nil(); ------------------ | | 831| 0|#define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1) | | ------------------ | | | | 822| 0| janet_nanbox_from_bits(janet_nanbox_tag(t) | (p)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39495| 0| } else { 39496| 0| in = janet_wrap_integer(0); ------------------ | | 967| 0|#define janet_wrap_integer(x) janet_wrap_number((int32_t)(x)) | | ------------------ | | | | 835| 0|#define janet_wrap_number(r) janet_nanbox_from_double(r) | | ------------------ ------------------ 39497| 0| } 39498| 0| break; 39499| 0| } 39500| 0| } 39501| 0| fiber->child = NULL; 39502| 0| } 39503| | 39504| | /* Handle new fibers being resumed with a non-nil value */ 39505| 68.6k| if (old_status == JANET_STATUS_NEW && !janet_checktype(in, JANET_NIL)) { ------------------ | | 806| 68.6k| (((t) == JANET_NUMBER) \ | | ------------------ | | | Branch (806:6): [Folded, False: 68.6k] | | ------------------ | | 807| 68.6k| ? janet_nanbox_isnumber(x) \ | | ------------------ | | | | 803| 0| (!isnan((x).number) || ((((x).u64 >> 47) & 0xF) == JANET_NUMBER)) | | | | ------------------ | | | | | Branch (803:6): [True: 0, False: 0] | | | | | Branch (803:28): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 808| 68.6k| : janet_nanbox_checkauxtype((x), (t))) | | ------------------ | | | | 800| 68.6k| (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 790| 68.6k|#define JANET_NANBOX_TAGBITS 0xFFFF800000000000llu | | | | ------------------ | | | | (((x).u64 & JANET_NANBOX_TAGBITS) == janet_nanbox_tag((type))) | | | | ------------------ | | | | | | 793| 68.6k|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 68.6k|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (39505:9): [True: 68.6k, False: 0] | Branch (39505:43): [True: 0, False: 68.6k] ------------------ 39506| 0| Janet *stack = fiber->data + fiber->frame; 39507| 0| JanetFunction *func = janet_stack_frame(stack)->func; ------------------ | | 854| 0|#define janet_stack_frame(s) ((JanetStackFrame *)((s) - JANET_FRAME_SIZE)) | | ------------------ | | | | 1026| 0|#define JANET_FRAME_SIZE 4 | | ------------------ ------------------ 39508| 0| if (func) { ------------------ | Branch (39508:13): [True: 0, False: 0] ------------------ 39509| 0| if (func->def->arity > 0) { ------------------ | Branch (39509:17): [True: 0, False: 0] ------------------ 39510| 0| stack[0] = in; 39511| 0| } else if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) { ------------------ | | 1097| 0|#define JANET_FUNCDEF_FLAG_VARARG 0x10000 ------------------ | Branch (39511:24): [True: 0, False: 0] ------------------ 39512| 0| stack[0] = janet_wrap_tuple(janet_tuple_n(&in, 1)); ------------------ | | 843| 0|#define janet_wrap_tuple(s) janet_nanbox_wrap_c((s), JANET_TUPLE) | | ------------------ | | | | 828| 0| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39513| 0| } 39514| 0| } 39515| 0| } 39516| | 39517| | /* If this is a nested continue (root_fiber already set), root the fiber 39518| | * so it survives GC. janet_collect only marks root_fiber, so without 39519| | * this a nested fiber (e.g., from janet_pcall in a C function) would be 39520| | * invisible to GC and could be collected while actively running. */ 39521| 68.6k| int fiber_rooted = (janet_vm.root_fiber != NULL); 39522| 68.6k| if (fiber_rooted) { ------------------ | Branch (39522:9): [True: 0, False: 68.6k] ------------------ 39523| 0| janet_gcroot(janet_wrap_fiber(fiber)); ------------------ | | 844| 0|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39524| 0| } 39525| | 39526| | /* Save global state */ 39527| 68.6k| JanetTryState tstate; 39528| 68.6k| JanetSignal sig = janet_try(&tstate); ------------------ | | 1981| 68.6k|#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf)) ------------------ 39529| 68.6k| if (!sig) { ------------------ | Branch (39529:9): [True: 68.6k, False: 0] ------------------ 39530| | /* Normal setup */ 39531| 68.6k| if (janet_vm.root_fiber == NULL) janet_vm.root_fiber = fiber; ------------------ | Branch (39531:13): [True: 68.6k, False: 0] ------------------ 39532| 68.6k| janet_vm.fiber = fiber; 39533| 68.6k| janet_fiber_set_status(fiber, JANET_STATUS_ALIVE); ------------------ | | 849| 68.6k|#define janet_fiber_set_status(f, s) do {\ | | 850| 68.6k| (f)->flags &= ~JANET_FIBER_STATUS_MASK;\ | | ------------------ | | | | 830| 68.6k|#define JANET_FIBER_STATUS_MASK 0x3F0000 | | ------------------ | | 851| 68.6k| (f)->flags |= (s) << JANET_FIBER_STATUS_OFFSET;\ | | ------------------ | | | | 832| 68.6k|#define JANET_FIBER_STATUS_OFFSET 16 | | ------------------ | | 852| 68.6k|} while (0) | | ------------------ | | | Branch (852:10): [Folded, False: 68.6k] | | ------------------ ------------------ 39534| 68.6k| sig = run_vm(fiber, in); 39535| 68.6k| } 39536| | 39537| | /* Restore */ 39538| 68.6k| if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL; ------------------ | Branch (39538:9): [True: 68.6k, False: 0] ------------------ 39539| 68.6k| janet_fiber_set_status(fiber, sig); ------------------ | | 849| 68.6k|#define janet_fiber_set_status(f, s) do {\ | | 850| 68.6k| (f)->flags &= ~JANET_FIBER_STATUS_MASK;\ | | ------------------ | | | | 830| 68.6k|#define JANET_FIBER_STATUS_MASK 0x3F0000 | | ------------------ | | 851| 68.6k| (f)->flags |= (s) << JANET_FIBER_STATUS_OFFSET;\ | | ------------------ | | | | 832| 68.6k|#define JANET_FIBER_STATUS_OFFSET 16 | | ------------------ | | 852| 68.6k|} while (0) | | ------------------ | | | Branch (852:10): [Folded, False: 68.6k] | | ------------------ ------------------ 39540| 68.6k| janet_restore(&tstate); 39541| 68.6k| if (fiber_rooted) { ------------------ | Branch (39541:9): [True: 0, False: 68.6k] ------------------ 39542| 0| janet_gcunroot(janet_wrap_fiber(fiber)); ------------------ | | 844| 0|#define janet_wrap_fiber(s) janet_nanbox_wrap_((s), JANET_FIBER) | | ------------------ | | | | 825| 0| janet_nanbox_from_pointer((p), janet_nanbox_tag(t)) | | | | ------------------ | | | | | | 793| 0|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | ------------------ | | | | | | | | 792| 0|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 39543| 0| } 39544| 68.6k| fiber->last_value = tstate.payload; 39545| 68.6k| *out = tstate.payload; 39546| | 39547| 68.6k| return sig; 39548| 68.6k|} janet.c:janet_method_lookup: 38263| 132|static Janet janet_method_lookup(Janet x, const char *name) { 38264| 132| return method_to_fun(janet_ckeywordv(name), x); ------------------ | | 1843| 132|#define janet_ckeywordv(cstr) janet_wrap_keyword(janet_ckeyword(cstr)) | | ------------------ | | | | 850| 132|#define janet_wrap_keyword(s) janet_nanbox_wrap_c((s), JANET_KEYWORD) | | | | ------------------ | | | | | | 828| 132| janet_nanbox_from_cpointer((p), janet_nanbox_tag(t)) | | | | | | ------------------ | | | | | | | | 793| 132|#define janet_nanbox_tag(type) (janet_nanbox_lowtag(type) << 47) | | | | | | | | ------------------ | | | | | | | | | | 792| 132|#define janet_nanbox_lowtag(type) ((uint64_t)(type) | 0x1FFF0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 38265| 132|} janet.c:janet_method_invoke: 38203| 2.94M|static Janet janet_method_invoke(Janet method, int32_t argc, Janet *argv) { 38204| 2.94M| switch (janet_type(method)) { ------------------ | | 795| 2.94M| (isnan((x).number) \ | | 796| 2.94M| ? (JanetType) (((x).u64 >> 47) & 0xF) \ | | 797| 2.94M| : JANET_NUMBER) ------------------ | Branch (38204:13): [True: 2.94M, False: 0] ------------------ 38205| 0| case JANET_CFUNCTION: ------------------ | Branch (38205:9): [True: 0, False: 2.94M] ------------------ 38206| 0| return (janet_unwrap_cfunction(method))(argc, argv); ------------------ | | 869| 0|#define janet_unwrap_cfunction(x) ((JanetCFunction)janet_nanbox_to_pointer(x)) ------------------ 38207| 0| case JANET_FUNCTION: { ------------------ | Branch (38207:9): [True: 0, False: 2.94M] ------------------ 38208| 0| JanetFunction *fun = janet_unwrap_function(method); ------------------ | | 868| 0|#define janet_unwrap_function(x) ((JanetFunction *)janet_nanbox_to_pointer(x)) ------------------ 38209| 0| return janet_call(fun, argc, argv); 38210| 0| } 38211| 3| case JANET_ABSTRACT: { ------------------ | Branch (38211:9): [True: 3, False: 2.94M] ------------------ 38212| 3| JanetAbstract abst = janet_unwrap_abstract(method); ------------------ | | 866| 3|#define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x)) ------------------ 38213| 3| const JanetAbstractType *at = janet_abstract_type(abst); ------------------ | | 1899| 3|#define janet_abstract_type(u) (janet_abstract_head(u)->type) | | ------------------ | | | | 1897| 3|#define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data))) | | ------------------ ------------------ 38214| 3| if (NULL != at->call) { ------------------ | Branch (38214:17): [True: 0, False: 3] ------------------ 38215| 0| return at->call(abst, argc, argv); 38216| 0| } 38217| 3| } 38218| | /* fallthrough */ 38219| 1.63M| case JANET_STRING: ------------------ | Branch (38219:9): [True: 1.63M, False: 1.31M] ------------------ 38220| 2.46M| case JANET_BUFFER: ------------------ | Branch (38220:9): [True: 826k, False: 2.12M] ------------------ 38221| 2.46M| case JANET_TABLE: ------------------ | Branch (38221:9): [True: 0, False: 2.94M] ------------------ 38222| 2.46M| case JANET_STRUCT: ------------------ | Branch (38222:9): [True: 0, False: 2.94M] ------------------ 38223| 2.94M| case JANET_ARRAY: ------------------ | Branch (38223:9): [True: 487k, False: 2.46M] ------------------ 38224| 2.94M| case JANET_TUPLE: { ------------------ | Branch (38224:9): [True: 0, False: 2.94M] ------------------ 38225| 2.94M| if (argc != 1) { ------------------ | Branch (38225:17): [True: 0, False: 2.94M] ------------------ 38226| 0| janet_panicf("%v called with %d arguments, possibly expected 1", method, argc); 38227| 0| } 38228| 2.94M| return janet_in(method, argv[0]); 38229| 2.94M| } 38230| 0| default: { ------------------ | Branch (38230:9): [True: 0, False: 2.94M] ------------------ 38231| 0| if (argc != 1) { ------------------ | Branch (38231:17): [True: 0, False: 0] ------------------ 38232| 0| janet_panicf("%v called with %d arguments, possibly expected 1", method, argc); 38233| 0| } 38234| 0| return janet_in(argv[0], method); 38235| 0| } 38236| 2.94M| } 38237| 2.94M|} LLVMFuzzerTestOneInput: 9| 264|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 10| | 11| | /* init Janet */ 12| 264| janet_init(); 13| | 14| | /* fuzz the compiler in src/core/compile.c: parse the untrusted source and 15| | compile each produced form to bytecode */ 16| 264| JanetTable *env = janet_core_env(NULL); 17| 264| JanetParser parser; 18| 264| janet_parser_init(&parser); 19| | 20| 264| JanetTryState tstate; 21| 264| if (janet_try(&tstate) == JANET_SIGNAL_OK) { ------------------ | | 1981| 264|#define janet_try(state) (janet_try_init(state), (JanetSignal) setjmp((state)->buf)) ------------------ | Branch (21:9): [True: 264, False: 0] ------------------ 22| 23.5M| for (size_t i = 0; i < size; i++) { ------------------ | Branch (22:28): [True: 23.5M, False: 92] ------------------ 23| 23.5M| if (janet_parser_status(&parser) == JANET_PARSE_ERROR) ------------------ | Branch (23:17): [True: 172, False: 23.5M] ------------------ 24| 172| break; 25| 23.5M| janet_parser_consume(&parser, data[i]); 26| 23.6M| while (janet_parser_has_more(&parser)) { ------------------ | Branch (26:20): [True: 57.2k, False: 23.5M] ------------------ 27| 57.2k| Janet form = janet_parser_produce(&parser); 28| 57.2k| JanetCompileResult res = janet_compile(form, env, janet_cstring("fuzz")); 29| 57.2k| (void) res; 30| 57.2k| } 31| 23.5M| } 32| 264| } 33| 264| janet_restore(&tstate); 34| | 35| 264| janet_parser_deinit(&parser); 36| | 37| | /* cleanup Janet */ 38| 264| janet_deinit(); 39| | 40| 264| return 0; 41| 264|}