VEP_Parse: 613| 1.62k|{ 614| 1.62k| const char *e; 615| 1.62k| struct vep_match *vm; 616| 1.62k| int i; 617| | 618| 1.62k| CHECK_OBJ_NOTNULL(vep, VEP_MAGIC); ------------------ | | 66| 1.62k| do { \ | | 67| 1.62k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 68| 1.62k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 69| 1.62k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.62k] | | ------------------ ------------------ 619| 1.62k| assert(l > 0); ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 620| | 621| 1.62k| if (vep->startup) { ------------------ | Branch (621:6): [True: 1.62k, False: 0] ------------------ 622| | /* 623| | * We must force the GZIP header out as a SKIP string, 624| | * otherwise an object starting with ver_p = ""; 629| 1.62k| vep->last_mark = SKIP; 630| 1.62k| vep_mark_common(vep, vep->ver_p, VERBATIM); 631| 1.62k| vep->startup = 0; 632| 1.62k| AZ(vep->hack_p); ------------------ | | 83| 1.62k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.62k] | | ------------------ ------------------ 633| 1.62k| vep->hack_p = p; 634| 1.62k| } 635| | 636| 1.62k| vep->ver_p = p; 637| | 638| 1.62k| e = p + l; 639| | 640| 631k| while (p < e) { ------------------ | Branch (640:9): [True: 629k, False: 1.62k] ------------------ 641| 629k| AN(vep->state); ------------------ | | 84| 629k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 629k|#define assert(e) \ | | | | 66| 629k|do { \ | | | | 67| 629k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 629k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 629k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 629k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 629k] | | ------------------ ------------------ 642| 629k| Debug("EP %s %d (%.*s) [%.*s]\n", 643| 629k| vep->state, 644| 629k| vep->remove, 645| 629k| vep->tag_i, vep->tag, 646| 629k| (e - p) > 10 ? 10 : (int)(e-p), p); 647| 629k| assert(p >= vep->ver_p); ------------------ | | 65| 629k|#define assert(e) \ | | 66| 629k|do { \ | | 67| 629k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 629k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 629k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 629k] | | ------------------ ------------------ 648| | 649| | /****************************************************** 650| | * SECTION A 651| | */ 652| | 653| 629k| if (vep->state == VEP_START) { ------------------ | Branch (653:7): [True: 3.44k, False: 626k] ------------------ 654| 3.44k| if (vep->flags.esi_remove_bom && ------------------ | Branch (654:8): [True: 3.32k, False: 118] ------------------ 655| 3.32k| *p == (char)0xeb) { ------------------ | Branch (655:8): [True: 1.85k, False: 1.47k] ------------------ 656| 1.85k| vep->match = vep_match_bom; 657| 1.85k| vep->state = VEP_MATCH; 658| 1.85k| } else 659| 1.59k| vep->state = VEP_BOM; 660| 626k| } else if (vep->state == VEP_BOM) { ------------------ | Branch (660:14): [True: 1.60k, False: 624k] ------------------ 661| 1.60k| vep_mark_skip(vep, p); 662| 1.60k| if (vep->flags.esi_disable_xml_check) ------------------ | Branch (662:8): [True: 1.52k, False: 80] ------------------ 663| 1.52k| vep->state = VEP_NEXTTAG; 664| 80| else 665| 80| vep->state = VEP_TESTXML; 666| 624k| } else if (vep->state == VEP_TESTXML) { ------------------ | Branch (666:14): [True: 80, False: 624k] ------------------ 667| | /* 668| | * If the first non-whitespace char is different 669| | * from '<' we assume this is not XML. 670| | */ 671| 302| while (p < e && vct_islws(*p)) ------------------ | | 72| 293|#define vct_islws(x) vct_is(x, VCT_LWS) | | ------------------ | | | | 39| 293|#define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 38| 293|#define VCT_CRLF (1<<1) | | | | ------------------ | | | | #define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 37| 293|#define VCT_OWS (1<<0) | | | | ------------------ | | ------------------ | | | Branch (72:22): [True: 222, False: 71] | | ------------------ ------------------ | Branch (671:11): [True: 293, False: 9] ------------------ 672| 222| p++; 673| 80| vep_mark_verbatim(vep, p); 674| 80| if (p < e && *p == '<') { ------------------ | Branch (674:8): [True: 71, False: 9] | Branch (674:17): [True: 7, False: 64] ------------------ 675| 7| p++; 676| 7| vep->state = VEP_STARTTAG; 677| 73| } else if (p < e && *p == (char)0xeb) { ------------------ | Branch (677:15): [True: 64, False: 9] | Branch (677:24): [True: 5, False: 59] ------------------ 678| 5| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, 679| 5| "WARN: No ESI processing, " 680| 5| "first char not '<' but BOM." 681| 5| " (See feature esi_remove_bom)" 682| 5| ); 683| 5| vep->state = VEP_NOTXML; 684| 68| } else if (p < e) { ------------------ | Branch (684:15): [True: 59, False: 9] ------------------ 685| 59| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, 686| 59| "WARN: No ESI processing, " 687| 59| "first char not '<'." 688| 59| " (See feature esi_disable_xml_check)" 689| 59| ); 690| 59| vep->state = VEP_NOTXML; 691| 59| } 692| 624k| } else if (vep->state == VEP_NOTXML) { ------------------ | Branch (692:14): [True: 64, False: 624k] ------------------ 693| | /* 694| | * This is not recognized as XML, just skip thru 695| | * vfp_esi_end() will handle the rest 696| | */ 697| 64| p = e; 698| 64| vep_mark_verbatim(vep, p); 699| | 700| | /****************************************************** 701| | * SECTION B 702| | */ 703| | 704| 624k| } else if (vep->state == VEP_NOTMYTAG) { ------------------ | Branch (704:14): [True: 25.6k, False: 598k] ------------------ 705| 25.6k| if (vep->flags.esi_ignore_other_elements) { ------------------ | Branch (705:8): [True: 24.1k, False: 1.55k] ------------------ 706| 24.1k| p++; 707| 24.1k| vep->state = VEP_NEXTTAG; 708| 24.1k| } else { 709| 1.55k| vep->tag_i = 0; 710| 186k| while (p < e) { ------------------ | Branch (710:12): [True: 186k, False: 16] ------------------ 711| 186k| if (*p++ == '>') { ------------------ | Branch (711:10): [True: 1.53k, False: 185k] ------------------ 712| 1.53k| vep->state = VEP_NEXTTAG; 713| 1.53k| break; 714| 1.53k| } 715| 186k| } 716| 1.55k| } 717| 25.6k| if (p == e && !vep->remove) ------------------ | Branch (717:8): [True: 54, False: 25.6k] | Branch (717:18): [True: 53, False: 1] ------------------ 718| 53| vep_mark_verbatim(vep, p); 719| 598k| } else if (vep->state == VEP_NEXTTAG) { ------------------ | Branch (719:14): [True: 102k, False: 496k] ------------------ 720| | /* 721| | * Hunt for start of next tag and keep an eye 722| | * out for end of EsiCmt if armed. 723| | */ 724| 102k| vep->emptytag = 0; 725| 102k| vep->attr = NULL; 726| 102k| vep->dostuff = NULL; 727| 13.4M| while (p < e && *p != '<') { ------------------ | Branch (727:11): [True: 13.4M, False: 324] | Branch (727:20): [True: 13.3M, False: 101k] ------------------ 728| 13.3M| if (vep->esicmt_p == NULL) { ------------------ | Branch (728:9): [True: 12.6M, False: 741k] ------------------ 729| 12.6M| p++; 730| 12.6M| continue; 731| 12.6M| } 732| 741k| if (*p != *vep->esicmt_p) { ------------------ | Branch (732:9): [True: 628k, False: 112k] ------------------ 733| 628k| p++; 734| 628k| vep->esicmt_p = vep->esicmt; 735| 628k| continue; 736| 628k| } 737| 112k| if (!vep->remove && vep->esicmt_p == vep->esicmt) ------------------ | Branch (737:9): [True: 112k, False: 781] | Branch (737:25): [True: 38.7k, False: 73.3k] ------------------ 738| 38.7k| vep_mark_verbatim(vep, p); 739| 112k| p++; 740| 112k| if (*++vep->esicmt_p == '\0') { ------------------ | Branch (740:9): [True: 35.9k, False: 76.8k] ------------------ 741| 35.9k| vep->esi_found = 1; 742| 35.9k| vep->esicmt = NULL; 743| 35.9k| vep->esicmt_p = NULL; 744| | /* 745| | * The end of the esicmt 746| | * should not be emitted. 747| | * But the stuff before should 748| | */ 749| 35.9k| vep_mark_skip(vep, p); 750| 35.9k| } 751| 112k| } 752| 102k| if (p < e) { ------------------ | Branch (752:8): [True: 101k, False: 324] ------------------ 753| 101k| if (!vep->remove) ------------------ | Branch (753:9): [True: 88.0k, False: 13.8k] ------------------ 754| 88.0k| vep_mark_verbatim(vep, p); 755| 101k| assert(*p == '<'); ------------------ | | 65| 101k|#define assert(e) \ | | 66| 101k|do { \ | | 67| 101k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 101k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 101k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 101k] | | ------------------ ------------------ 756| 101k| p++; 757| 101k| vep->state = VEP_STARTTAG; 758| 101k| } else if (vep->esicmt_p == vep->esicmt && !vep->remove) ------------------ | Branch (758:15): [True: 247, False: 77] | Branch (758:47): [True: 224, False: 23] ------------------ 759| 224| vep_mark_verbatim(vep, p); 760| | 761| | /****************************************************** 762| | * SECTION C 763| | */ 764| | 765| 496k| } else if (vep->state == VEP_STARTTAG) { ------------------ | Branch (765:14): [True: 101k, False: 394k] ------------------ 766| | /* Start of tag, set up match table */ 767| 101k| vep->endtag = 0; 768| 101k| vep->match = vep_match_starttag; 769| 101k| vep->state = VEP_MATCH; 770| 394k| } else if (vep->state == VEP_COMMENT) { ------------------ | Branch (770:14): [True: 1.50k, False: 393k] ------------------ 771| 1.50k| vep->esicmt_p = vep->esicmt = NULL; 772| 1.50k| vep->until_p = vep->until = "-->"; 773| 1.50k| vep->until_s = VEP_NEXTTAG; 774| 1.50k| vep->state = VEP_UNTIL; 775| 393k| } else if (vep->state == VEP_COMMENTESI) { ------------------ | Branch (775:14): [True: 36.9k, False: 356k] ------------------ 776| 36.9k| if (vep->remove) ------------------ | Branch (776:8): [True: 411, False: 36.4k] ------------------ 777| 411| vep_error(vep, 778| 411| "ESI 1.0 Nested "; 781| 36.9k| vep->state = VEP_NEXTTAG; 782| 36.9k| vep_mark_skip(vep, p); 783| 356k| } else if (vep->state == VEP_CDATA) { ------------------ | Branch (783:14): [True: 3.47k, False: 352k] ------------------ 784| | /* 785| | * Easy: just look for the end of CDATA 786| | */ 787| 3.47k| vep->until_p = vep->until = "]]>"; 788| 3.47k| vep->until_s = VEP_NEXTTAG; 789| 3.47k| vep->state = VEP_UNTIL; 790| 352k| } else if (vep->state == VEP_ESIENDTAG) { ------------------ | Branch (790:14): [True: 4.63k, False: 348k] ------------------ 791| 4.63k| vep->endtag = 1; 792| 4.63k| vep->state = VEP_ESITAG; 793| 348k| } else if (vep->state == VEP_ESITAG) { ------------------ | Branch (793:14): [True: 33.9k, False: 314k] ------------------ 794| 33.9k| vep->in_esi_tag = 1; 795| 33.9k| vep->esi_found = 1; 796| 33.9k| vep_mark_skip(vep, p); 797| 33.9k| vep->match = vep_match_esi; 798| 33.9k| vep->state = VEP_MATCH; 799| 314k| } else if (vep->state == VEP_ESIINCLUDE) { ------------------ | Branch (799:14): [True: 17.1k, False: 297k] ------------------ 800| 17.1k| if (vep->remove) { ------------------ | Branch (800:8): [True: 3.59k, False: 13.5k] ------------------ 801| 3.59k| vep_error(vep, 802| 3.59k| "ESI 1.0 element" 803| 3.59k| " nested in "); 804| 3.59k| vep->state = VEP_TAGERROR; 805| 13.5k| } else if (vep->endtag) { ------------------ | Branch (805:15): [True: 558, False: 12.9k] ------------------ 806| 558| vep_error(vep, 807| 558| "ESI 1.0 illegal end-tag"); 808| 558| vep->state = VEP_TAGERROR; 809| 12.9k| } else { 810| 12.9k| vep->dostuff = vep_do_include; 811| 12.9k| vep->state = VEP_INTAG; 812| 12.9k| vep->attr = vep_match_attr_include; 813| 12.9k| } 814| 297k| } else if (vep->state == VEP_ESIREMOVE) { ------------------ | Branch (814:14): [True: 9.89k, False: 287k] ------------------ 815| 9.89k| vep->dostuff = vep_do_remove; 816| 9.89k| vep->state = VEP_INTAG; 817| 287k| } else if (vep->state == VEP_ESICOMMENT) { ------------------ | Branch (817:14): [True: 2.02k, False: 285k] ------------------ 818| 2.02k| if (vep->remove) { ------------------ | Branch (818:8): [True: 735, False: 1.29k] ------------------ 819| 735| vep_error(vep, 820| 735| "ESI 1.0 element" 821| 735| " nested in "); 822| 735| vep->state = VEP_TAGERROR; 823| 1.29k| } else if (vep->endtag) { ------------------ | Branch (823:15): [True: 333, False: 958] ------------------ 824| 333| vep_error(vep, 825| 333| "ESI 1.0 illegal end-tag"); 826| 333| vep->state = VEP_TAGERROR; 827| 958| } else { 828| 958| vep->dostuff = vep_do_comment; 829| 958| vep->state = VEP_INTAG; 830| 958| } 831| 285k| } else if (vep->state == VEP_ESIBOGON) { ------------------ | Branch (831:14): [True: 4.87k, False: 280k] ------------------ 832| 4.87k| vep_error(vep, 833| 4.87k| "ESI 1.0 element"); 834| 4.87k| vep->state = VEP_TAGERROR; 835| | 836| | /****************************************************** 837| | * SECTION D 838| | */ 839| | 840| 280k| } else if (vep->state == VEP_INTAG) { ------------------ | Branch (840:14): [True: 37.8k, False: 242k] ------------------ 841| 37.8k| vep->tag_i = 0; 842| 44.0k| while (p < e && vct_islws(*p) && !vep->emptytag) { ------------------ | | 72| 88.0k|#define vct_islws(x) vct_is(x, VCT_LWS) | | ------------------ | | | | 39| 44.0k|#define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 38| 44.0k|#define VCT_CRLF (1<<1) | | | | ------------------ | | | | #define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 37| 44.0k|#define VCT_OWS (1<<0) | | | | ------------------ | | ------------------ | | | Branch (72:22): [True: 6.23k, False: 37.8k] | | ------------------ ------------------ | Branch (842:11): [True: 44.0k, False: 19] | Branch (842:37): [True: 6.23k, False: 0] ------------------ 843| 6.23k| p++; 844| 6.23k| vep->canattr = 1; 845| 6.23k| } 846| 37.8k| if (p < e && *p == '/' && !vep->emptytag) { ------------------ | Branch (846:8): [True: 37.8k, False: 19] | Branch (846:17): [True: 3.08k, False: 34.7k] | Branch (846:30): [True: 3.08k, False: 0] ------------------ 847| 3.08k| p++; 848| 3.08k| vep->emptytag = 1; 849| 3.08k| vep->canattr = 0; 850| 3.08k| } 851| 37.8k| if (p < e && *p == '>') { ------------------ | Branch (851:8): [True: 37.7k, False: 31] | Branch (851:17): [True: 16.4k, False: 21.3k] ------------------ 852| 16.4k| p++; 853| 16.4k| AN(vep->dostuff); ------------------ | | 84| 16.4k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 16.4k|#define assert(e) \ | | | | 66| 16.4k|do { \ | | | | 67| 16.4k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 16.4k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 16.4k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 16.4k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 16.4k] | | ------------------ ------------------ 854| 16.4k| vep_mark_skip(vep, p); 855| 16.4k| vep->dostuff(vep, DO_TAG); 856| 16.4k| vep->in_esi_tag = 0; 857| 16.4k| vep->state = VEP_NEXTTAG; 858| 21.4k| } else if (p < e && vep->emptytag) { ------------------ | Branch (858:15): [True: 21.3k, False: 31] | Branch (858:24): [True: 437, False: 20.9k] ------------------ 859| 437| vep_error(vep, 860| 437| "XML 1.0 '>' does not follow '/' in tag"); 861| 437| vep->state = VEP_TAGERROR; 862| 20.9k| } else if (p < e && vep->canattr && ------------------ | Branch (862:15): [True: 20.9k, False: 31] | Branch (862:24): [True: 19.8k, False: 1.06k] ------------------ 863| 19.8k| vct_isxmlnamestart(*p)) { ------------------ | | 85| 19.8k|#define vct_isxmlnamestart(x) vct_is(x, VCT_XMLNAMESTART) | | ------------------ | | | | 45| 19.8k|#define VCT_XMLNAMESTART (1<<7) | | ------------------ | | | Branch (85:31): [True: 19.0k, False: 825] | | ------------------ ------------------ 864| 19.0k| vep->state = VEP_ATTR; 865| 19.0k| } else if (p < e) { ------------------ | Branch (865:15): [True: 1.88k, False: 31] ------------------ 866| 1.88k| vep_error(vep, 867| 1.88k| "XML 1.0 Illegal attribute start char"); 868| 1.88k| vep->state = VEP_TAGERROR; 869| 1.88k| } 870| 242k| } else if (vep->state == VEP_TAGERROR) { ------------------ | Branch (870:14): [True: 17.2k, False: 225k] ------------------ 871| 7.06M| while (p < e && *p != '>') ------------------ | Branch (871:11): [True: 7.06M, False: 139] | Branch (871:20): [True: 7.04M, False: 17.1k] ------------------ 872| 7.04M| p++; 873| 17.2k| if (p < e) { ------------------ | Branch (873:8): [True: 17.1k, False: 139] ------------------ 874| 17.1k| p++; 875| 17.1k| vep_mark_skip(vep, p); 876| 17.1k| vep->in_esi_tag = 0; 877| 17.1k| vep->state = VEP_NEXTTAG; 878| 17.1k| if (vep->attr_vsb) ------------------ | Branch (878:9): [True: 1.11k, False: 16.0k] ------------------ 879| 1.11k| VSB_destroy(&vep->attr_vsb); 880| 17.1k| } 881| | 882| | /****************************************************** 883| | * SECTION E 884| | */ 885| | 886| 225k| } else if (vep->state == VEP_ATTR) { ------------------ | Branch (886:14): [True: 19.0k, False: 206k] ------------------ 887| 19.0k| AZ(vep->attr_delim); ------------------ | | 83| 19.0k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 19.0k|#define assert(e) \ | | | | 66| 19.0k|do { \ | | | | 67| 19.0k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 19.0k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 19.0k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 19.0k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 19.0k] | | ------------------ ------------------ 888| 19.0k| if (vep->attr == NULL) { ------------------ | Branch (888:8): [True: 4.44k, False: 14.6k] ------------------ 889| 4.44k| p++; 890| 4.44k| AZ(vep->attr_vsb); ------------------ | | 83| 4.44k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 4.44k|#define assert(e) \ | | | | 66| 4.44k|do { \ | | | | 67| 4.44k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.44k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.44k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.44k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 4.44k] | | ------------------ ------------------ 891| 4.44k| vep->state = VEP_SKIPATTR; 892| 14.6k| } else { 893| 14.6k| vep->match = vep->attr; 894| 14.6k| vep->state = VEP_MATCH; 895| 14.6k| } 896| 206k| } else if (vep->state == VEP_SKIPATTR) { ------------------ | Branch (896:14): [True: 7.53k, False: 198k] ------------------ 897| 25.9k| while (p < e && vct_isxmlname(*p)) ------------------ | | 86| 25.9k|#define vct_isxmlname(x) vct_is(x, VCT_XMLNAMESTART | VCT_XMLNAME) | | ------------------ | | | | 45| 25.9k|#define VCT_XMLNAMESTART (1<<7) | | ------------------ | | #define vct_isxmlname(x) vct_is(x, VCT_XMLNAMESTART | VCT_XMLNAME) | | ------------------ | | | | 46| 25.9k|#define VCT_XMLNAME (1<<8) | | ------------------ | | | Branch (86:26): [True: 18.3k, False: 7.52k] | | ------------------ ------------------ | Branch (897:11): [True: 25.9k, False: 13] ------------------ 898| 18.3k| p++; 899| 7.53k| if (p < e && *p == '=') { ------------------ | Branch (899:8): [True: 7.52k, False: 13] | Branch (899:17): [True: 4.17k, False: 3.34k] ------------------ 900| 4.17k| p++; 901| 4.17k| vep->state = VEP_ATTRDELIM; 902| 4.17k| } else if (p < e && *p == '>') { ------------------ | Branch (902:15): [True: 3.34k, False: 13] | Branch (902:24): [True: 538, False: 2.80k] ------------------ 903| 538| vep->state = VEP_INTAG; 904| 2.82k| } else if (p < e && *p == '/') { ------------------ | Branch (904:15): [True: 2.80k, False: 13] | Branch (904:24): [True: 483, False: 2.32k] ------------------ 905| 483| vep->state = VEP_INTAG; 906| 2.33k| } else if (p < e && vct_issp(*p)) { ------------------ | | 70| 2.32k|#define vct_issp(x) vct_is(x, VCT_OWS) | | ------------------ | | | | 37| 2.32k|#define VCT_OWS (1<<0) | | ------------------ | | | Branch (70:21): [True: 1.37k, False: 954] | | ------------------ ------------------ | Branch (906:15): [True: 2.32k, False: 13] ------------------ 907| 1.37k| vep->state = VEP_INTAG; 908| 1.37k| } else if (p < e) { ------------------ | Branch (908:15): [True: 954, False: 13] ------------------ 909| 954| vep_error(vep, 910| 954| "XML 1.0 Illegal attr char"); 911| 954| vep->state = VEP_TAGERROR; 912| 954| } 913| 198k| } else if (vep->state == VEP_ATTRGETVAL) { ------------------ | Branch (913:14): [True: 11.5k, False: 187k] ------------------ 914| 11.5k| AZ(vep->attr_vsb); ------------------ | | 83| 11.5k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 11.5k|#define assert(e) \ | | | | 66| 11.5k|do { \ | | | | 67| 11.5k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 11.5k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 11.5k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 11.5k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 11.5k] | | ------------------ ------------------ 915| 11.5k| vep->attr_vsb = VSB_new_auto(); 916| 11.5k| vep->state = VEP_ATTRDELIM; 917| 187k| } else if (vep->state == VEP_ATTRDELIM) { ------------------ | Branch (917:14): [True: 15.6k, False: 171k] ------------------ 918| 15.6k| AZ(vep->attr_delim); ------------------ | | 83| 15.6k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 15.6k|#define assert(e) \ | | | | 66| 15.6k|do { \ | | | | 67| 15.6k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 15.6k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 15.6k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 15.6k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 15.6k] | | ------------------ ------------------ 919| 15.6k| if (*p == '"' || *p == '\'') { ------------------ | Branch (919:8): [True: 751, False: 14.9k] | Branch (919:21): [True: 439, False: 14.4k] ------------------ 920| 1.19k| vep->attr_delim = *p++; 921| 1.19k| vep->state = VEP_ATTRVAL; 922| 14.4k| } else if (!vct_issp(*p)) { ------------------ | | 70| 14.4k|#define vct_issp(x) vct_is(x, VCT_OWS) | | ------------------ | | | | 37| 14.4k|#define VCT_OWS (1<<0) | | ------------------ ------------------ | Branch (922:15): [True: 13.1k, False: 1.31k] ------------------ 923| 13.1k| vep->attr_delim = ' '; 924| 13.1k| vep->state = VEP_ATTRVAL; 925| 13.1k| } else { 926| 1.31k| vep_error(vep, 927| 1.31k| "XML 1.0 Illegal attribute delimiter"); 928| 1.31k| vep->state = VEP_TAGERROR; 929| 1.31k| } 930| | 931| 171k| } else if (vep->state == VEP_ATTRVAL) { ------------------ | Branch (931:14): [True: 14.3k, False: 157k] ------------------ 932| 15.1M| while (p < e && *p != '>' && *p != vep->attr_delim && ------------------ | Branch (932:11): [True: 15.1M, False: 90] | Branch (932:20): [True: 15.1M, False: 1.03k] | Branch (932:33): [True: 15.1M, False: 12.6k] ------------------ 933| 15.1M| (vep->attr_delim != ' ' || !vct_issp(*p))) { ------------------ | | 70| 15.1M|#define vct_issp(x) vct_is(x, VCT_OWS) | | ------------------ | | | | 37| 15.1M|#define VCT_OWS (1<<0) | | ------------------ ------------------ | Branch (933:8): [True: 11.3k, False: 15.1M] | Branch (933:34): [True: 15.1M, False: 607] ------------------ 934| 15.1M| if (vep->attr_vsb != NULL) ------------------ | Branch (934:9): [True: 15.1M, False: 41.9k] ------------------ 935| 15.1M| VSB_putc(vep->attr_vsb, *p); 936| 15.1M| p++; 937| 15.1M| } 938| 14.3k| if (p < e && *p == '>') { ------------------ | Branch (938:8): [True: 14.2k, False: 90] | Branch (938:17): [True: 1.03k, False: 13.2k] ------------------ 939| 1.03k| vep_error(vep, 940| 1.03k| "XML 1.0 Missing end attribute delimiter"); 941| 1.03k| vep->state = VEP_TAGERROR; 942| 1.03k| vep->attr_delim = 0; 943| 1.03k| if (vep->attr_vsb != NULL) { ------------------ | Branch (943:9): [True: 626, False: 406] ------------------ 944| 626| AZ(VSB_finish(vep->attr_vsb)); ------------------ | | 83| 626|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 626|#define assert(e) \ | | | | 66| 626|do { \ | | | | 67| 626| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 626] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 626|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 626] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 626] | | ------------------ ------------------ 945| 626| VSB_destroy(&vep->attr_vsb); 946| 626| } 947| 13.3k| } else if (p < e) { ------------------ | Branch (947:15): [True: 13.2k, False: 90] ------------------ 948| 13.2k| vep->attr_delim = 0; 949| 13.2k| p++; 950| 13.2k| vep->state = VEP_INTAG; 951| 13.2k| if (vep->attr_vsb != NULL) { ------------------ | Branch (951:9): [True: 9.72k, False: 3.49k] ------------------ 952| 9.72k| AZ(VSB_finish(vep->attr_vsb)); ------------------ | | 83| 9.72k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 9.72k|#define assert(e) \ | | | | 66| 9.72k|do { \ | | | | 67| 9.72k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.72k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.72k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.72k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 9.72k] | | ------------------ ------------------ 953| 9.72k| AN(vep->dostuff); ------------------ | | 84| 9.72k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 9.72k|#define assert(e) \ | | | | 66| 9.72k|do { \ | | | | 67| 9.72k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.72k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.72k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.72k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 9.72k] | | ------------------ ------------------ 954| 9.72k| vep->dostuff(vep, DO_ATTR); 955| 9.72k| vep->attr_vsb = NULL; 956| 9.72k| } 957| 13.2k| } 958| | 959| | /****************************************************** 960| | * Utility Section 961| | */ 962| | 963| 157k| } else if (vep->state == VEP_MATCH) { ------------------ | Branch (963:14): [True: 152k, False: 4.98k] ------------------ 964| | /* 965| | * Match against a table 966| | */ 967| 152k| vm = vep_match(vep, p, e); 968| 152k| vep->match_hit = vm; 969| 152k| if (vm != NULL) { ------------------ | Branch (969:8): [True: 152k, False: 36] ------------------ 970| 152k| if (vm->match != NULL) ------------------ | Branch (970:9): [True: 118k, False: 33.6k] ------------------ 971| 118k| p += vstrlen(vm->match); ------------------ | | 362| 118k|# define vstrlen(s) __builtin_strlen(s) ------------------ 972| 152k| vep->state = *vm->state; 973| 152k| vep->match = NULL; 974| 152k| vep->tag_i = 0; 975| 152k| } else { 976| 36| assert(p + sizeof(vep->tag) >= e); ------------------ | | 65| 36|#define assert(e) \ | | 66| 36|do { \ | | 67| 36| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 36] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 36|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 36] | | ------------------ ------------------ 977| 36| vmemcpy(vep->tag, p, e - p); ------------------ | | 375| 36|# define vmemcpy(d, s, n) __builtin_memcpy(d, s, n) ------------------ 978| 36| vep->tag_i = e - p; 979| 36| vep->state = VEP_MATCHBUF; 980| 36| p = e; 981| 36| } 982| 152k| } else if (vep->state == VEP_MATCHBUF) { ------------------ | Branch (982:14): [True: 0, False: 4.98k] ------------------ 983| | /* 984| | * Match against a table while split over input 985| | * sections. 986| | */ 987| 0| AN(vep->match); ------------------ | | 84| 0|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 0] | | ------------------ ------------------ 988| 0| i = sizeof(vep->tag) - vep->tag_i; 989| 0| if (i > e - p) ------------------ | Branch (989:8): [True: 0, False: 0] ------------------ 990| 0| i = e - p; 991| 0| vmemcpy(vep->tag + vep->tag_i, p, i); ------------------ | | 375| 0|# define vmemcpy(d, s, n) __builtin_memcpy(d, s, n) ------------------ 992| 0| vm = vep_match(vep, vep->tag, 993| 0| vep->tag + vep->tag_i + i); 994| 0| Debug("MB (%.*s) tag_i %d i %d = vm %p match %s\n", 995| 0| vep->tag_i + i, vep->tag, 996| 0| vep->tag_i, 997| 0| i, 998| 0| vm, 999| 0| vm ? vm->match : "(nil)"); 1000| | 1001| 0| if (vm == NULL) { ------------------ | Branch (1001:8): [True: 0, False: 0] ------------------ 1002| 0| vep->tag_i += i; 1003| 0| p += i; 1004| 0| assert(p == e); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 1005| 0| } else { 1006| 0| vep->match_hit = vm; 1007| 0| vep->state = *vm->state; 1008| 0| if (vm->match != NULL) { ------------------ | Branch (1008:9): [True: 0, False: 0] ------------------ 1009| 0| i = vstrlen(vm->match); ------------------ | | 362| 0|# define vstrlen(s) __builtin_strlen(s) ------------------ 1010| 0| if (i > vep->tag_i) ------------------ | Branch (1010:10): [True: 0, False: 0] ------------------ 1011| 0| p += i - vep->tag_i; 1012| 0| } 1013| 0| vep->match = NULL; 1014| 0| vep->tag_i = 0; 1015| 0| } 1016| 4.98k| } else if (vep->state == VEP_UNTIL) { ------------------ | Branch (1016:14): [True: 4.98k, False: 0] ------------------ 1017| | /* 1018| | * Skip until we see magic string 1019| | */ 1020| 10.3M| while (p < e) { ------------------ | Branch (1020:11): [True: 10.3M, False: 71] ------------------ 1021| 10.3M| if (*p++ != *vep->until_p++) { ------------------ | Branch (1021:9): [True: 10.3M, False: 25.6k] ------------------ 1022| 10.3M| vep->until_p = vep->until; 1023| 10.3M| } else if (*vep->until_p == '\0') { ------------------ | Branch (1023:16): [True: 4.90k, False: 20.7k] ------------------ 1024| 4.90k| vep->state = vep->until_s; 1025| 4.90k| break; 1026| 4.90k| } 1027| 10.3M| } 1028| 4.98k| if (p == e && !vep->remove) ------------------ | Branch (1028:8): [True: 81, False: 4.89k] | Branch (1028:18): [True: 76, False: 5] ------------------ 1029| 76| vep_mark_verbatim(vep, p); 1030| 4.98k| } else { 1031| 0| Debug("*** Unknown state %s\n", vep->state); 1032| 0| WRONG("WRONG ESI PARSER STATE"); ------------------ | | 88| 0|#define WRONG(expl) \ | | 89| 0|do { \ | | 90| 0| VAS_Fail(__func__, __FILE__, __LINE__, expl, VAS_WRONG); \ | | 91| 0|} while (0) | | ------------------ | | | Branch (91:10): [Folded, False: 0] | | ------------------ ------------------ 1033| 0| } 1034| 629k| } 1035| | /* 1036| | * We must always mark up the storage we got, try to do so 1037| | * in the most efficient way, in particular with respect to 1038| | * minimizing and limiting use of pending. 1039| | */ 1040| 1.62k| if (p == vep->ver_p) ------------------ | Branch (1040:6): [True: 1.01k, False: 611] ------------------ 1041| 1.01k| ; 1042| 611| else if (vep->in_esi_tag) ------------------ | Branch (1042:11): [True: 358, False: 253] ------------------ 1043| 358| vep_mark_skip(vep, p); 1044| 253| else if (vep->remove) ------------------ | Branch (1044:11): [True: 38, False: 215] ------------------ 1045| 38| vep_mark_skip(vep, p); 1046| 215| else 1047| 215| vep_mark_pending(vep, p); 1048| 1.62k|} VEP_Init: 1072| 1.62k|{ 1073| 1.62k| struct vep_state *vep; 1074| | 1075| 1.62k| CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC); ------------------ | | 66| 1.62k| do { \ | | 67| 1.62k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 68| 1.62k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 69| 1.62k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.62k] | | ------------------ ------------------ 1076| 1.62k| CHECK_OBJ_NOTNULL(req, HTTP_MAGIC); ------------------ | | 66| 1.62k| do { \ | | 67| 1.62k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 68| 1.62k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 69| 1.62k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.62k] | | ------------------ ------------------ 1077| 1.62k| vep = WS_Alloc(vc->resp->ws, sizeof *vep); 1078| 1.62k| if (vep == NULL) { ------------------ | Branch (1078:6): [True: 0, False: 1.62k] ------------------ 1079| 0| VSLb(vc->wrk->vsl, SLT_VCL_Error, 1080| 0| "VEP_Init() workspace overflow"); 1081| 0| return (NULL); 1082| 0| } 1083| | 1084| 1.62k| INIT_OBJ(vep, VEP_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 1085| 1.62k| vep->flags = flags; 1086| 1.62k| vep->url = req->hd[HTTP_HDR_URL].b; 1087| 1.62k| vep->vc = vc; 1088| 1.62k| vep->vsb = VSB_new_auto(); 1089| 1.62k| AN(vep->vsb); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 1090| | 1091| 1.62k| if (cb != NULL) { ------------------ | Branch (1091:6): [True: 0, False: 1.62k] ------------------ 1092| 0| vep->dogzip = 1; 1093| | /* XXX */ 1094| 0| VSB_printf(vep->vsb, "%c", VEC_GZ); ------------------ | | 32| 0|#define VEC_GZ (0x21) ------------------ 1095| 0| vep->cb = cb; 1096| 0| vep->cb_priv = cb_priv; 1097| 1.62k| } else { 1098| 1.62k| vep->cb = vep_default_cb; 1099| 1.62k| vep->cb_priv = &vep->cb_x; 1100| 1.62k| } 1101| | 1102| 1.62k| vep->state = VEP_START; 1103| 1.62k| vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 38| 1.62k|# define crc32 z_crc32 ------------------ vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 217| 1.62k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 1104| 1.62k| vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 38| 1.62k|# define crc32 z_crc32 ------------------ vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 217| 1.62k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 1105| | 1106| 1.62k| vep->startup = 1; 1107| 1.62k| return (vep); 1108| 1.62k|} VEP_Finish: 1115| 1.62k|{ 1116| 1.62k| ssize_t l, lcb; 1117| | 1118| 1.62k| CHECK_OBJ_NOTNULL(vep, VEP_MAGIC); ------------------ | | 66| 1.62k| do { \ | | 67| 1.62k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 68| 1.62k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 69| 1.62k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.62k] | | ------------------ ------------------ 1119| | 1120| 1.62k| if (vep->include_src) ------------------ | Branch (1120:6): [True: 48, False: 1.57k] ------------------ 1121| 48| VSB_destroy(&vep->include_src); 1122| 1.62k| if (vep->attr_vsb) ------------------ | Branch (1122:6): [True: 42, False: 1.58k] ------------------ 1123| 42| VSB_destroy(&vep->attr_vsb); 1124| | 1125| 1.62k| if (vep->state != VEP_START && ------------------ | Branch (1125:6): [True: 1.61k, False: 11] ------------------ 1126| 1.61k| vep->state != VEP_BOM && ------------------ | Branch (1126:6): [True: 1.61k, False: 0] ------------------ 1127| 1.61k| vep->state != VEP_TESTXML && ------------------ | Branch (1127:6): [True: 1.60k, False: 9] ------------------ 1128| 1.60k| vep->state != VEP_NOTXML && ------------------ | Branch (1128:6): [True: 1.54k, False: 64] ------------------ 1129| 1.54k| vep->state != VEP_NEXTTAG) { ------------------ | Branch (1129:6): [True: 585, False: 958] ------------------ 1130| 585| vep_error(vep, "VEP ended inside a tag"); 1131| 585| } 1132| | 1133| 1.62k| if (vep->o_pending) ------------------ | Branch (1133:6): [True: 215, False: 1.41k] ------------------ 1134| 215| vep_mark_common(vep, vep->ver_p, vep->last_mark); 1135| 1.62k| if (vep->o_wait > 0) { ------------------ | Branch (1135:6): [True: 1.59k, False: 30] ------------------ 1136| 1.59k| lcb = vep->cb(vep->vc, vep->cb_priv, 0, VGZ_ALIGN); 1137| 1.59k| vep_emit_common(vep, lcb - vep->o_last, vep->last_mark); 1138| 1.59k| } 1139| | // NB: We don't account for PAD+SUM+LEN in gzipped objects 1140| 1.62k| (void)vep->cb(vep->vc, vep->cb_priv, 0, VGZ_FINISH); 1141| | 1142| 1.62k| AZ(VSB_finish(vep->vsb)); ------------------ | | 83| 1.62k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.62k] | | ------------------ ------------------ 1143| 1.62k| l = VSB_len(vep->vsb); 1144| 1.62k| if (vep->esi_found && l > 0) ------------------ | Branch (1144:6): [True: 1.12k, False: 498] | Branch (1144:24): [True: 1.12k, False: 0] ------------------ 1145| 1.12k| return (vep->vsb); 1146| 498| VSB_destroy(&vep->vsb); 1147| | return (NULL); 1148| 1.62k|} cache_esi_parse.c:vep_mark_common: 320| 271k|{ 321| 271k| ssize_t l, lcb; 322| | 323| 271k| assert(mark == SKIP || mark == VERBATIM); ------------------ | | 65| 271k|#define assert(e) \ | | 66| 271k|do { \ | | 67| 400k| if (!(e)) { \ | | ------------------ | | | Branch (67:8): [True: 142k, False: 129k] | | | Branch (67:8): [True: 129k, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 271k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 271k] | | ------------------ ------------------ 324| | 325| | /* The NO-OP case, no data, no pending data & no change of mode */ 326| 271k| if (vep->last_mark == mark && p == vep->ver_p && vep->o_pending == 0) ------------------ | Branch (326:6): [True: 75.4k, False: 196k] | Branch (326:32): [True: 215, False: 75.1k] | Branch (326:51): [True: 0, False: 215] ------------------ 327| 0| return; 328| | 329| | /* 330| | * If we changed mode, emit whatever the opposite mode 331| | * assembled before the pending bytes. 332| | */ 333| | 334| 271k| if (vep->last_mark != mark && (vep->o_wait > 0 || vep->startup)) { ------------------ | Branch (334:6): [True: 196k, False: 75.4k] | Branch (334:33): [True: 170k, False: 25.7k] | Branch (334:52): [True: 1.62k, False: 24.1k] ------------------ 335| 172k| lcb = vep->cb(vep->vc, vep->cb_priv, 0, 336| 172k| mark == VERBATIM ? VGZ_RESET : VGZ_ALIGN); ------------------ | Branch (336:7): [True: 96.8k, False: 75.2k] ------------------ 337| 172k| vep_emit_common(vep, lcb - vep->o_last, vep->last_mark); 338| 172k| vep->o_last = lcb; 339| 172k| vep->o_wait = 0; 340| 172k| } 341| | 342| | /* Transfer pending bytes CRC into active mode CRC */ 343| 271k| if (vep->o_pending) { ------------------ | Branch (343:6): [True: 215, False: 271k] ------------------ 344| 215| (void)vep->cb(vep->vc, vep->cb_priv, vep->o_pending, 345| 215| VGZ_NORMAL); 346| 215| if (vep->o_crc == 0) { ------------------ | Branch (346:7): [True: 59, False: 156] ------------------ 347| 59| vep->crc = vep->crcp; 348| 59| vep->o_crc = vep->o_pending; 349| 156| } else { 350| 156| vep->crc = crc32_combine(vep->crc, ------------------ | | 39| 156|# define crc32_combine z_crc32_combine ------------------ 351| 156| vep->crcp, vep->o_pending); 352| 156| vep->o_crc += vep->o_pending; 353| 156| } 354| 215| vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 38| 215|# define crc32 z_crc32 ------------------ vep->crcp = crc32(0L, Z_NULL, 0); ------------------ | | 217| 215|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 355| 215| vep->o_wait += vep->o_pending; 356| 215| vep->o_pending = 0; 357| 215| } 358| | 359| | /* * Process this bit of input */ 360| 271k| AN(vep->ver_p); ------------------ | | 84| 271k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 271k|#define assert(e) \ | | | | 66| 271k|do { \ | | | | 67| 271k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 271k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 271k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 271k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 271k] | | ------------------ ------------------ 361| 271k| l = p - vep->ver_p; 362| 271k| assert(l >= 0); ------------------ | | 65| 271k|#define assert(e) \ | | 66| 271k|do { \ | | 67| 271k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 271k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 271k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 271k] | | ------------------ ------------------ 363| 271k| vep->crc = crc32(vep->crc, (const void*)vep->ver_p, l); ------------------ | | 38| 271k|# define crc32 z_crc32 ------------------ 364| 271k| vep->o_crc += l; 365| 271k| vep->ver_p = p; 366| | 367| 271k| vep->o_wait += l; 368| 271k| vep->last_mark = mark; 369| 271k| (void)vep->cb(vep->vc, vep->cb_priv, l, VGZ_NORMAL); 370| 271k|} cache_esi_parse.c:vep_mark_skip: 382| 142k|{ 383| | 384| 142k| vep_mark_common(vep, p, SKIP); 385| 142k| vep->nm_skip++; 386| 142k|} cache_esi_parse.c:vep_mark_verbatim: 374| 127k|{ 375| | 376| 127k| vep_mark_common(vep, p, VERBATIM); 377| 127k| vep->nm_verbatim++; 378| 127k|} cache_esi_parse.c:vep_error: 205| 24.2k|{ 206| 24.2k| VSC_C_main->esi_errors++; 207| 24.2k| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "ERR: after %zd %s", 208| 24.2k| vep->o_last, p); 209| 24.2k|} cache_esi_parse.c:vep_do_include: 478| 17.0k|{ 479| 17.0k| const char *p, *q, *h; 480| 17.0k| ssize_t l; 481| 17.0k| char incl; 482| | 483| 17.0k| Debug("DO_INCLUDE(%d)\n", what); 484| 17.0k| if (what == DO_ATTR) { ------------------ | Branch (484:6): [True: 9.72k, False: 7.34k] ------------------ 485| 9.72k| Debug("ATTR (%s) (%s)\n", vep->match_hit->match, 486| 9.72k| VSB_data(vep->attr_vsb)); 487| 9.72k| if (!vstrcmp("src=", vep->match_hit->match)) { ------------------ | | 356| 9.72k|# define vstrcmp(s1, s2) __builtin_strcmp(s1, s2) ------------------ | Branch (487:7): [True: 9.72k, False: 0] ------------------ 488| 9.72k| include_attr_src(vep); 489| 9.72k| return; 490| 9.72k| } 491| 0| if (!vstrcmp("onerror=", vep->match_hit->match)) { ------------------ | | 356| 0|# define vstrcmp(s1, s2) __builtin_strcmp(s1, s2) ------------------ | Branch (491:7): [True: 0, False: 0] ------------------ 492| 0| include_attr_onerror(vep); 493| 0| return; 494| 0| } 495| 0| WRONG("Unhandled attribute"); ------------------ | | 88| 0|#define WRONG(expl) \ | | 89| 0|do { \ | | 90| 0| VAS_Fail(__func__, __FILE__, __LINE__, expl, VAS_WRONG); \ | | 91| 0|} while (0) | | ------------------ | | | Branch (91:10): [Folded, False: 0] | | ------------------ ------------------ 496| 0| } 497| 7.34k| assert(what == DO_TAG); ------------------ | | 65| 7.34k|#define assert(e) \ | | 66| 7.34k|do { \ | | 67| 7.34k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 7.34k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 7.34k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 7.34k] | | ------------------ ------------------ 498| 7.34k| if (!vep->emptytag) ------------------ | Branch (498:6): [True: 7.05k, False: 284] ------------------ 499| 7.05k| vep_warn(vep, "ESI 1.0 lacks final '/'"); 500| 7.34k| if (vep->include_src == NULL) { ------------------ | Branch (500:6): [True: 591, False: 6.75k] ------------------ 501| 591| vep_error(vep, "ESI 1.0 lacks src attr"); 502| 591| return; 503| 591| } 504| | 505| | /* 506| | * Strictly speaking, we ought to spit out any piled up skip before 507| | * emitting the VEC for the include, but objectively that makes no 508| | * difference and robs us of a chance to collapse another skip into 509| | * this on so we don't do that. 510| | * However, we cannot tolerate any verbatim stuff piling up. 511| | * The mark_skip() before calling dostuff should have taken 512| | * care of that. Make sure. 513| | */ 514| 6.75k| assert(vep->o_wait == 0 || vep->last_mark == SKIP); ------------------ | | 65| 6.75k|#define assert(e) \ | | 66| 6.75k|do { \ | | 67| 13.5k| if (!(e)) { \ | | ------------------ | | | Branch (67:8): [True: 0, False: 6.75k] | | | Branch (67:8): [True: 6.75k, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 6.75k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 6.75k] | | ------------------ ------------------ 515| | /* XXX: what if it contains NUL bytes ?? */ 516| 6.75k| p = VSB_data(vep->include_src); 517| 6.75k| l = VSB_len(vep->include_src); 518| 6.75k| h = 0; 519| | 520| 6.75k| incl = vep->include_continue ? VEC_IC : VEC_IA; ------------------ | | 43| 0|#define VEC_IC (0x60 + 9) ------------------ incl = vep->include_continue ? VEC_IC : VEC_IA; ------------------ | | 42| 13.5k|#define VEC_IA (0x40 + 9) ------------------ | Branch (520:9): [True: 0, False: 6.75k] ------------------ 521| | 522| 6.75k| if (l > 7 && !vmemcmp(p, "http://", 7)) { ------------------ | | 344| 4.56k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) ------------------ | Branch (522:6): [True: 4.56k, False: 2.18k] | Branch (522:15): [True: 852, False: 3.71k] ------------------ 523| 852| h = p + 7; 524| 852| p = strchr(h, '/'); 525| 852| if (p == NULL) { ------------------ | Branch (525:7): [True: 262, False: 590] ------------------ 526| 262| vep_error(vep, 527| 262| "ESI 1.0 invalid src= URL"); 528| 262| vep->state = VEP_TAGERROR; 529| 262| AZ(vep->attr_vsb); ------------------ | | 83| 262|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 262|#define assert(e) \ | | | | 66| 262|do { \ | | | | 67| 262| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 262] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 262|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 262] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 262] | | ------------------ ------------------ 530| 262| VSB_destroy(&vep->include_src); 531| 262| return; 532| 262| } 533| 590| Debug("HOST <%.*s> PATH <%s>\n", (int)(p-h),h, p); 534| 590| VSB_printf(vep->vsb, "%c", incl); 535| 590| VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0); 536| 5.89k| } else if (l > 8 && !vmemcmp(p, "https://", 8)) { ------------------ | | 344| 3.61k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) ------------------ | Branch (536:13): [True: 3.61k, False: 2.28k] | Branch (536:22): [True: 2.03k, False: 1.57k] ------------------ 537| 2.03k| if (!vep->flags.esi_ignore_https) { ------------------ | Branch (537:7): [True: 261, False: 1.77k] ------------------ 538| 261| vep_warn(vep, 539| 261| "ESI 1.0 with https:// ignored"); 540| 261| vep->state = VEP_TAGERROR; 541| 261| AZ(vep->attr_vsb); ------------------ | | 83| 261|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 261|#define assert(e) \ | | | | 66| 261|do { \ | | | | 67| 261| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 261] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 261|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 261] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 261] | | ------------------ ------------------ 542| 261| VSB_destroy(&vep->include_src); 543| 261| return; 544| 261| } 545| 1.77k| vep_warn(vep, 546| 1.77k| "ESI 1.0 https:// treated as http://"); 547| 1.77k| h = p + 8; 548| 1.77k| p = strchr(h, '/'); 549| 1.77k| if (p == NULL) { ------------------ | Branch (549:7): [True: 1.11k, False: 654] ------------------ 550| 1.11k| vep_error(vep, 551| 1.11k| "ESI 1.0 invalid src= URL"); 552| 1.11k| vep->state = VEP_TAGERROR; 553| 1.11k| AZ(vep->attr_vsb); ------------------ | | 83| 1.11k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.11k|#define assert(e) \ | | | | 66| 1.11k|do { \ | | | | 67| 1.11k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.11k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.11k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.11k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.11k] | | ------------------ ------------------ 554| 1.11k| VSB_destroy(&vep->include_src); 555| 1.11k| return; 556| 1.11k| } 557| 654| VSB_printf(vep->vsb, "%c", incl); 558| 654| VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0); 559| 3.86k| } else if (*p == '/') { ------------------ | Branch (559:13): [True: 1.31k, False: 2.55k] ------------------ 560| 1.31k| VSB_printf(vep->vsb, "%c", incl); 561| 1.31k| VSB_printf(vep->vsb, "%c", 0); 562| 2.55k| } else { 563| 2.55k| VSB_printf(vep->vsb, "%c", incl); 564| 2.55k| VSB_printf(vep->vsb, "%c", 0); 565| | /* Look for the last / before a '?' */ 566| 2.55k| h = NULL; 567| 5.10k| for (q = vep->url; *q && *q != '?'; q++) ------------------ | Branch (567:22): [True: 2.55k, False: 2.55k] | Branch (567:28): [True: 2.55k, False: 0] ------------------ 568| 2.55k| if (*q == '/') ------------------ | Branch (568:8): [True: 2.55k, False: 0] ------------------ 569| 2.55k| h = q; 570| 2.55k| if (h == NULL) ------------------ | Branch (570:7): [True: 0, False: 2.55k] ------------------ 571| 0| h = q + 1; 572| | 573| 2.55k| Debug("INCL:: [%.*s]/[%s]\n", 574| 2.55k| (int)(h - vep->url), vep->url, p); 575| 2.55k| VSB_printf(vep->vsb, "%.*s/", (int)(h - vep->url), vep->url); 576| 2.55k| } 577| 5.10k| l -= (p - VSB_data(vep->include_src)); 578| 4.72M| for (q = p; *q != '\0'; ) { ------------------ | Branch (578:14): [True: 4.71M, False: 5.10k] ------------------ 579| 4.71M| if (*q == '&') { ------------------ | Branch (579:7): [True: 60.2k, False: 4.65M] ------------------ 580| 60.2k|#define R(w,f,r) \ 581| 60.2k| if (q + w <= p + l && !vmemcmp(q, f, w)) { \ 582| 60.2k| VSB_printf(vep->vsb, "%c", r); \ 583| 60.2k| q += w; \ 584| 60.2k| continue; \ 585| 60.2k| } 586| 60.2k| R(6, "'", '\''); ------------------ | | 581| 60.2k| if (q + w <= p + l && !vmemcmp(q, f, w)) { \ | | ------------------ | | | | 344| 58.8k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) | | ------------------ | | | Branch (581:8): [True: 58.8k, False: 1.31k] | | | Branch (581:26): [True: 7.32k, False: 51.5k] | | ------------------ | | 582| 7.32k| VSB_printf(vep->vsb, "%c", r); \ | | 583| 7.32k| q += w; \ | | 584| 7.32k| continue; \ | | 585| 7.32k| } ------------------ 587| 52.8k| R(6, """, '"'); ------------------ | | 581| 52.8k| if (q + w <= p + l && !vmemcmp(q, f, w)) { \ | | ------------------ | | | | 344| 51.5k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) | | ------------------ | | | Branch (581:8): [True: 51.5k, False: 1.31k] | | | Branch (581:26): [True: 1.75k, False: 49.8k] | | ------------------ | | 582| 1.75k| VSB_printf(vep->vsb, "%c", r); \ | | 583| 1.75k| q += w; \ | | 584| 1.75k| continue; \ | | 585| 1.75k| } ------------------ 588| 51.1k| R(4, "<", '<'); ------------------ | | 581| 51.1k| if (q + w <= p + l && !vmemcmp(q, f, w)) { \ | | ------------------ | | | | 344| 50.2k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) | | ------------------ | | | Branch (581:8): [True: 50.2k, False: 849] | | | Branch (581:26): [True: 1.18k, False: 49.0k] | | ------------------ | | 582| 1.18k| VSB_printf(vep->vsb, "%c", r); \ | | 583| 1.18k| q += w; \ | | 584| 1.18k| continue; \ | | 585| 1.18k| } ------------------ 589| 49.9k| R(4, ">", '>'); ------------------ | | 581| 49.9k| if (q + w <= p + l && !vmemcmp(q, f, w)) { \ | | ------------------ | | | | 344| 49.0k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) | | ------------------ | | | Branch (581:8): [True: 49.0k, False: 849] | | | Branch (581:26): [True: 6.79k, False: 42.2k] | | ------------------ | | 582| 6.79k| VSB_printf(vep->vsb, "%c", r); \ | | 583| 6.79k| q += w; \ | | 584| 6.79k| continue; \ | | 585| 6.79k| } ------------------ 590| 43.1k| R(5, "&", '&'); ------------------ | | 581| 43.1k| if (q + w <= p + l && !vmemcmp(q, f, w)) { \ | | ------------------ | | | | 344| 42.1k|# define vmemcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) | | ------------------ | | | Branch (581:8): [True: 42.1k, False: 1.04k] | | | Branch (581:26): [True: 551, False: 41.5k] | | ------------------ | | 582| 551| VSB_printf(vep->vsb, "%c", r); \ | | 583| 551| q += w; \ | | 584| 551| continue; \ | | 585| 551| } ------------------ 591| 42.5k| } 592| 4.70M| VSB_printf(vep->vsb, "%c", *q++); 593| 4.70M| } 594| 5.10k|#undef R 595| 5.10k| VSB_printf(vep->vsb, "%c", 0); 596| 5.10k| VSB_destroy(&vep->include_src); 597| 5.10k| vep->include_continue = 0; 598| 5.10k|} cache_esi_parse.c:include_attr_src: 439| 9.72k|{ 440| 9.72k| const char *p; 441| | 442| 9.72k| if (vep->include_src != NULL) { ------------------ | Branch (442:6): [True: 1.33k, False: 8.38k] ------------------ 443| 1.33k| vep_error(vep, 444| 1.33k| "ESI 1.0 " 445| 1.33k| "has multiple src= attributes"); 446| 1.33k| vep->state = VEP_TAGERROR; 447| 1.33k| VSB_destroy(&vep->attr_vsb); 448| 1.33k| VSB_destroy(&vep->include_src); 449| 1.33k| return; 450| 1.33k| } 451| 10.9M| for (p = VSB_data(vep->attr_vsb); *p != '\0'; p++) ------------------ | Branch (451:36): [True: 10.9M, False: 8.13k] ------------------ 452| 10.9M| if (vct_islws(*p)) ------------------ | | 72| 10.9M|#define vct_islws(x) vct_is(x, VCT_LWS) | | ------------------ | | | | 39| 10.9M|#define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 38| 10.9M|#define VCT_CRLF (1<<1) | | | | ------------------ | | | | #define VCT_LWS (VCT_CRLF | VCT_OWS) | | | | ------------------ | | | | | | 37| 10.9M|#define VCT_OWS (1<<0) | | | | ------------------ | | ------------------ | | | Branch (72:22): [True: 254, False: 10.9M] | | ------------------ ------------------ 453| 254| break; 454| 8.38k| if (*p != '\0') { ------------------ | Branch (454:6): [True: 254, False: 8.13k] ------------------ 455| 254| vep_error(vep, 456| 254| "ESI 1.0 " 457| 254| "has whitespace in src= attribute"); 458| 254| vep->state = VEP_TAGERROR; 459| 254| VSB_destroy(&vep->attr_vsb); 460| 254| if (vep->include_src != NULL) ------------------ | Branch (460:7): [True: 0, False: 254] ------------------ 461| 0| VSB_destroy(&vep->include_src); 462| 254| return; 463| 254| } 464| 8.13k| vep->include_src = vep->attr_vsb; 465| | vep->attr_vsb = NULL; 466| 8.13k|} cache_esi_parse.c:vep_warn: 217| 9.09k|{ 218| 9.09k| VSC_C_main->esi_warnings++; 219| 9.09k| VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "WARN: after %zd %s", 220| 9.09k| vep->o_last, p); 221| 9.09k|} cache_esi_parse.c:vep_do_remove: 420| 8.20k|{ 421| 8.20k| Debug("DO_REMOVE(%d, end %d empty %d remove %d)\n", 422| 8.20k| what, vep->endtag, vep->emptytag, vep->remove); 423| 8.20k| assert(what == DO_TAG); ------------------ | | 65| 8.20k|#define assert(e) \ | | 66| 8.20k|do { \ | | 67| 8.20k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 8.20k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 8.20k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 8.20k] | | ------------------ ------------------ 424| 8.20k| if (vep->emptytag) ------------------ | Branch (424:6): [True: 1.82k, False: 6.37k] ------------------ 425| 1.82k| vep_error(vep, "ESI 1.0 not legal"); 426| 6.37k| else if (vep->remove && !vep->endtag) ------------------ | Branch (426:11): [True: 3.45k, False: 2.92k] | Branch (426:26): [True: 1.22k, False: 2.23k] ------------------ 427| 1.22k| vep_error(vep, "ESI 1.0 already open"); 428| 5.15k| else if (!vep->remove && vep->endtag) ------------------ | Branch (428:11): [True: 2.92k, False: 2.23k] | Branch (428:27): [True: 593, False: 2.32k] ------------------ 429| 593| vep_error(vep, "ESI 1.0 not open"); 430| 4.55k| else 431| 4.55k| vep->remove = !vep->endtag; 432| 8.20k|} cache_esi_parse.c:vep_do_comment: 408| 882|{ 409| 882| Debug("DO_COMMENT(%d)\n", what); 410| 882| assert(what == DO_TAG); ------------------ | | 65| 882|#define assert(e) \ | | 66| 882|do { \ | | 67| 882| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 882] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 882|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 882] | | ------------------ ------------------ 411| 882| if (!vep->emptytag) ------------------ | Branch (411:6): [True: 356, False: 526] ------------------ 412| 356| vep_error(vep, "ESI 1.0 needs final '/'"); 413| 882|} cache_esi_parse.c:vep_match: 229| 152k|{ 230| 152k| struct vep_match *vm; 231| 152k| const char *q, *r; 232| | 233| 152k| AN(vep->match); ------------------ | | 84| 152k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 152k|#define assert(e) \ | | | | 66| 152k|do { \ | | | | 67| 152k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 152k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 152k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 152k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 152k] | | ------------------ ------------------ 234| 492k| for (vm = vep->match; vm->match != NULL; vm++) { ------------------ | Branch (234:24): [True: 459k, False: 33.6k] ------------------ 235| 459k| assert(vstrlen(vm->match) <= sizeof (vep->tag)); ------------------ | | 65| 459k|#define assert(e) \ | | 66| 459k|do { \ | | 67| 459k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 459k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 459k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 459k] | | ------------------ ------------------ 236| 459k| r = b; 237| 1.14M| for (q = vm->match; *q != '\0' && r < e; q++, r++) ------------------ | Branch (237:23): [True: 1.02M, False: 118k] | Branch (237:37): [True: 1.02M, False: 36] ------------------ 238| 1.02M| if (*q != *r) ------------------ | Branch (238:8): [True: 340k, False: 689k] ------------------ 239| 340k| break; 240| 459k| if (*q == '\0') ------------------ | Branch (240:7): [True: 118k, False: 340k] ------------------ 241| 118k| break; 242| 340k| if (r == e) ------------------ | Branch (242:7): [True: 36, False: 340k] ------------------ 243| 36| return (NULL); 244| 340k| } 245| 152k| return (vm); 246| 152k|} cache_esi_parse.c:vep_mark_pending: 390| 215|{ 391| 215| ssize_t l; 392| | 393| 215| AN(vep->ver_p); ------------------ | | 84| 215|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 215|#define assert(e) \ | | | | 66| 215|do { \ | | | | 67| 215| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 215] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 215|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 215] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 215] | | ------------------ ------------------ 394| 215| l = p - vep->ver_p; 395| 215| assert(l > 0); ------------------ | | 65| 215|#define assert(e) \ | | 66| 215|do { \ | | 67| 215| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 215] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 215|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 215] | | ------------------ ------------------ 396| 215| vep->crcp = crc32(vep->crcp, (const void *)vep->ver_p, l); ------------------ | | 38| 215|# define crc32 z_crc32 ------------------ 397| 215| vep->ver_p = p; 398| | 399| 215| vep->o_pending += l; 400| 215| vep->nm_pending++; 401| 215|} cache_esi_parse.c:vep_default_cb: 1055| 447k|{ 1056| 447k| ssize_t *s; 1057| | 1058| 447k| CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC); ------------------ | | 66| 447k| do { \ | | 67| 447k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 447k|#define assert(e) \ | | | | 66| 447k|do { \ | | | | 67| 447k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 447k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 447k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 447k] | | | | ------------------ | | ------------------ | | 68| 447k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 447k|#define assert(e) \ | | | | 66| 447k|do { \ | | | | 67| 447k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 447k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 447k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 447k] | | | | ------------------ | | ------------------ | | 69| 447k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 447k] | | ------------------ ------------------ 1059| 447k| AN(priv); ------------------ | | 84| 447k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 447k|#define assert(e) \ | | | | 66| 447k|do { \ | | | | 67| 447k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 447k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 447k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 447k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 447k] | | ------------------ ------------------ 1060| 447k| s = priv; 1061| 447k| *s += l; 1062| 447k| (void)flg; 1063| 447k| return (*s); 1064| 447k|} cache_esi_parse.c:vep_emit_common: 298| 173k|{ 299| | 300| 173k| assert(l >= 0); ------------------ | | 65| 173k|#define assert(e) \ | | 66| 173k|do { \ | | 67| 173k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 173k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 173k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 173k] | | ------------------ ------------------ 301| 173k| if (l == 0) ------------------ | Branch (301:6): [True: 1.62k, False: 171k] ------------------ 302| 1.62k| return; 303| 171k| assert(mark == SKIP || mark == VERBATIM); ------------------ | | 65| 171k|#define assert(e) \ | | 66| 171k|do { \ | | 67| 247k| if (!(e)) { \ | | ------------------ | | | Branch (67:8): [True: 96.1k, False: 75.8k] | | | Branch (67:8): [True: 75.8k, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 171k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 171k] | | ------------------ ------------------ 304| 171k| if (mark == SKIP) ------------------ | Branch (304:6): [True: 96.1k, False: 75.8k] ------------------ 305| 96.1k| vep_emit_skip(vep, l); 306| 75.8k| else 307| 75.8k| vep_emit_verbatim(vep, l, vep->o_crc); 308| | 309| 171k| vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 38| 171k|# define crc32 z_crc32 ------------------ vep->crc = crc32(0L, Z_NULL, 0); ------------------ | | 217| 171k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 310| 171k| vep->o_crc = 0; 311| 171k| vep->o_total += l; 312| 171k|} cache_esi_parse.c:vep_emit_skip: 278| 96.1k|{ 279| | 280| 96.1k| vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8); ------------------ | | 39| 96.1k|#define VEC_S1 (0x60 + 1) ------------------ vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8); ------------------ | | 40| 96.1k|#define VEC_S2 (0x60 + 2) ------------------ vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8); ------------------ | | 41| 96.1k|#define VEC_S8 (0x60 + 8) ------------------ 281| 96.1k|} cache_esi_parse.c:vep_emit_len: 254| 171k|{ 255| 171k| uint8_t buf[9]; 256| | 257| 171k| assert(l > 0); ------------------ | | 65| 171k|#define assert(e) \ | | 66| 171k|do { \ | | 67| 171k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 171k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 171k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 171k] | | ------------------ ------------------ 258| 171k| if (l < 256) { ------------------ | Branch (258:6): [True: 170k, False: 1.42k] ------------------ 259| 170k| buf[0] = (uint8_t)m8; 260| 170k| buf[1] = (uint8_t)l; 261| 170k| assert((ssize_t)buf[1] == l); ------------------ | | 65| 170k|#define assert(e) \ | | 66| 170k|do { \ | | 67| 170k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 170k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 170k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 170k] | | ------------------ ------------------ 262| 170k| VSB_bcat(vep->vsb, buf, 2); 263| 170k| } else if (l < 65536) { ------------------ | Branch (263:13): [True: 1.25k, False: 170] ------------------ 264| 1.25k| buf[0] = (uint8_t)m16; 265| 1.25k| vbe16enc(buf + 1, (uint16_t)l); 266| 1.25k| assert((ssize_t)vbe16dec(buf + 1) == l); ------------------ | | 65| 1.25k|#define assert(e) \ | | 66| 1.25k|do { \ | | 67| 1.25k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.25k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.25k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.25k] | | ------------------ ------------------ 267| 1.25k| VSB_bcat(vep->vsb, buf, 3); 268| 1.25k| } else { 269| 170| buf[0] = (uint8_t)m64; 270| 170| vbe64enc(buf + 1, l); 271| 170| assert((ssize_t)vbe64dec(buf + 1) == l); ------------------ | | 65| 170|#define assert(e) \ | | 66| 170|do { \ | | 67| 170| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 170] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 170|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 170] | | ------------------ ------------------ 272| 170| VSB_bcat(vep->vsb, buf, 9); 273| 170| } 274| 171k|} cache_esi_parse.c:vep_emit_verbatim: 285| 75.8k|{ 286| 75.8k| uint8_t buf[4]; 287| | 288| 75.8k| vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8); ------------------ | | 33| 75.8k|#define VEC_V1 (0x40 + 1) ------------------ vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8); ------------------ | | 34| 75.8k|#define VEC_V2 (0x40 + 2) ------------------ vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8); ------------------ | | 35| 75.8k|#define VEC_V8 (0x40 + 8) ------------------ 289| 75.8k| if (vep->dogzip) { ------------------ | Branch (289:6): [True: 0, False: 75.8k] ------------------ 290| 0| vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8); ------------------ | | 36| 0|#define VEC_C1 (0x50 + 1) ------------------ vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8); ------------------ | | 37| 0|#define VEC_C2 (0x50 + 2) ------------------ vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8); ------------------ | | 38| 0|#define VEC_C8 (0x50 + 8) ------------------ 291| 0| vbe32enc(buf, vep->crc); 292| 0| VSB_bcat(vep->vsb, buf, sizeof buf); 293| 0| } 294| 75.8k|} WS_Rollback: 85| 1.62k|{ 86| | 87| 1.62k| WS_Assert(ws); 88| | 89| 1.62k| if (pp == 0) ------------------ | Branch (89:6): [True: 1.62k, False: 0] ------------------ 90| 1.62k| pp = (uintptr_t)ws->s; 91| 1.62k| ws_ClearOverflow(ws); 92| 1.62k| WS_Reset(ws, pp); 93| 1.62k|} cache_ws_common.c:ws_ClearOverflow: 60| 1.62k|{ 61| 1.62k| CHECK_OBJ_NOTNULL(ws, WS_MAGIC); ------------------ | | 66| 1.62k| do { \ | | 67| 1.62k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 68| 1.62k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 69| 1.62k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.62k] | | ------------------ ------------------ 62| | 63| 1.62k| ws->id[0] |= 0x20; // cheesy tolower() 64| 1.62k|} WS_Assert: 76| 9.76k|{ 77| 9.76k| struct ws_emu *we; 78| 9.76k| struct ws_alloc *wa, *wa2 = NULL; 79| 9.76k| size_t len; 80| | 81| 9.76k| CHECK_OBJ_NOTNULL(ws, WS_MAGIC); ------------------ | | 66| 9.76k| do { \ | | 67| 9.76k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 9.76k|#define assert(e) \ | | | | 66| 9.76k|do { \ | | | | 67| 9.76k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.76k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.76k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.76k] | | | | ------------------ | | ------------------ | | 68| 9.76k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 9.76k|#define assert(e) \ | | | | 66| 9.76k|do { \ | | | | 67| 9.76k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.76k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.76k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.76k] | | | | ------------------ | | ------------------ | | 69| 9.76k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 9.76k] | | ------------------ ------------------ 82| 9.76k| assert(ws->s != NULL); ------------------ | | 65| 9.76k|#define assert(e) \ | | 66| 9.76k|do { \ | | 67| 9.76k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.76k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.76k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.76k] | | ------------------ ------------------ 83| 9.76k| assert(PAOK(ws->s)); ------------------ | | 65| 9.76k|#define assert(e) \ | | 66| 9.76k|do { \ | | 67| 9.76k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.76k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.76k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.76k] | | ------------------ ------------------ 84| 9.76k| assert(ws->e != NULL); ------------------ | | 65| 9.76k|#define assert(e) \ | | 66| 9.76k|do { \ | | 67| 9.76k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.76k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.76k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.76k] | | ------------------ ------------------ 85| 9.76k| assert(PAOK(ws->e)); ------------------ | | 65| 9.76k|#define assert(e) \ | | 66| 9.76k|do { \ | | 67| 9.76k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.76k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.76k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.76k] | | ------------------ ------------------ 86| | 87| 9.76k| we = ws_emu(ws); 88| 9.76k| len = pdiff(ws->s, ws->e); 89| 9.76k| assert(len == we->len); ------------------ | | 65| 9.76k|#define assert(e) \ | | 66| 9.76k|do { \ | | 67| 9.76k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.76k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.76k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.76k] | | ------------------ ------------------ 90| | 91| 9.76k| len = 0; 92| 9.76k| VTAILQ_FOREACH(wa, &we->head, list) { ------------------ | | 460| 9.76k| for ((var) = VTAILQ_FIRST((head)); \ | | ------------------ | | | | 457| 9.76k|#define VTAILQ_FIRST(head) ((head)->vtqh_first) | | ------------------ | | 461| 14.6k| (var); \ | | ------------------ | | | Branch (461:6): [True: 4.88k, False: 9.76k] | | ------------------ | | 462| 9.76k| (var) = VTAILQ_NEXT((var), field)) | | ------------------ | | | | 542| 4.88k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ ------------------ 93| 4.88k| CHECK_OBJ_NOTNULL(wa, WS_ALLOC_MAGIC); ------------------ | | 66| 4.88k| do { \ | | 67| 4.88k| assert((ptr) != NULL); \ | | ------------------ | | | | 65| 4.88k|#define assert(e) \ | | | | 66| 4.88k|do { \ | | | | 67| 4.88k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.88k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.88k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.88k] | | | | ------------------ | | ------------------ | | 68| 4.88k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 4.88k|#define assert(e) \ | | | | 66| 4.88k|do { \ | | | | 67| 4.88k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.88k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.88k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.88k] | | | | ------------------ | | ------------------ | | 69| 4.88k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 4.88k] | | ------------------ ------------------ 94| 4.88k| wa2 = wa; 95| 4.88k| assert(len == wa->off); ------------------ | | 65| 4.88k|#define assert(e) \ | | 66| 4.88k|do { \ | | 67| 4.88k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 4.88k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 4.88k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 4.88k] | | ------------------ ------------------ 96| 4.88k| if (wa->ptr == ws->f || wa->ptr == NULL) /* reservation */ ------------------ | Branch (96:7): [True: 0, False: 4.88k] | Branch (96:27): [True: 0, False: 4.88k] ------------------ 97| 0| break; 98| 4.88k| AN(wa->len); ------------------ | | 84| 4.88k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 4.88k|#define assert(e) \ | | | | 66| 4.88k|do { \ | | | | 67| 4.88k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.88k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.88k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.88k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 4.88k] | | ------------------ ------------------ 99| 4.88k| len += PRNDUP(wa->len); ------------------ | | 153| 4.88k|#define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 4.88k|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ | | #define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 4.88k|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 100| 4.88k| assert(len <= we->len); ------------------ | | 65| 4.88k|#define assert(e) \ | | 66| 4.88k|do { \ | | 67| 4.88k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 4.88k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 4.88k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 4.88k] | | ------------------ ------------------ 101| 4.88k| } 102| | 103| 9.76k| if (wa != NULL) { ------------------ | Branch (103:6): [True: 0, False: 9.76k] ------------------ 104| 0| AZ(VTAILQ_NEXT(wa, list)); ------------------ | | 83| 0|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 0] | | ------------------ ------------------ 105| 0| if (wa->ptr == NULL) { ------------------ | Branch (105:7): [True: 0, False: 0] ------------------ 106| 0| AZ(wa->len); ------------------ | | 83| 0|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 0] | | ------------------ ------------------ 107| 0| assert(ws->f == ws->e); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 108| 0| assert(ws->r == ws->e); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 109| 0| } else { 110| 0| AN(wa->len); ------------------ | | 84| 0|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 0] | | ------------------ ------------------ 111| 0| assert(ws->f == wa->ptr); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 112| 0| assert(ws->r == ws->f + wa->len); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 113| 0| } 114| 0| len += PRNDUP(wa->len); ------------------ | | 153| 0|#define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ | | #define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 115| 0| assert(len <= we->len); ------------------ | | 65| 0|#define assert(e) \ | | 66| 0|do { \ | | 67| 0| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 0] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 0|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 0] | | ------------------ ------------------ 116| 9.76k| } else { 117| 9.76k| AZ(ws->f); ------------------ | | 83| 9.76k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 9.76k|#define assert(e) \ | | | | 66| 9.76k|do { \ | | | | 67| 9.76k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.76k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.76k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.76k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 9.76k] | | ------------------ ------------------ 118| 9.76k| AZ(ws->r); ------------------ | | 83| 9.76k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 9.76k|#define assert(e) \ | | | | 66| 9.76k|do { \ | | | | 67| 9.76k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.76k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.76k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.76k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 9.76k] | | ------------------ ------------------ 119| 9.76k| } 120| | 121| 9.76k| DSLb(DBG_WORKSPACE, "WS(%p) = (%s, %p %zu %zu %zu)", ------------------ | | 622| 9.76k| do { \ | | 623| 9.76k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 613| 9.76k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (613:21): [True: 0, False: 9.76k] | | | | ------------------ | | ------------------ | | 624| 9.76k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | ------------------ | | | Branch (624:23): [True: 0, False: 0] | | | Branch (624:23): [True: 0, False: 0] | | ------------------ | | 625| 9.76k| } while (0) | | ------------------ | | | Branch (625:11): [Folded, False: 9.76k] | | ------------------ ------------------ 122| 9.76k| ws, ws->id, ws->s, wa2 == NULL ? 0 : wa2->off + PRNDUP(wa2->len), 123| 9.76k| ws->r == NULL ? 0 : pdiff(ws->f, ws->r), 124| 9.76k| pdiff(ws->s, ws->e)); 125| 9.76k|} WS_Init: 159| 1.62k|{ 160| 1.62k| struct ws_emu *we; 161| | 162| 1.62k| DSLb(DBG_WORKSPACE, ------------------ | | 622| 1.62k| do { \ | | 623| 1.62k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 613| 1.62k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (613:21): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 624| 1.62k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 625| 1.62k| } while (0) | | ------------------ | | | Branch (625:11): [Folded, False: 1.62k] | | ------------------ ------------------ 163| 1.62k| "WS_Init(%p, \"%s\", %p, %u)", ws, id, space, len); 164| 1.62k| assert(space != NULL); ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 165| 1.62k| assert(PAOK(space)); ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 166| 1.62k| assert(len >= sizeof *we); ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 167| | 168| 1.62k| len = PRNDDN(len - 1); ------------------ | | 152| 1.62k|#define PRNDDN(p) ((uintptr_t)(p) & ~PALGN) /* Round down */ | | ------------------ | | | | 149| 1.62k|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 169| 1.62k| INIT_OBJ(ws, WS_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 170| 1.62k| ws->s = space; 171| 1.62k| ws->e = ws->s + len; 172| | 173| 1.62k| assert(id[0] & 0x20); // cheesy islower() ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 174| 1.62k| bstrcpy(ws->id, id); ------------------ | | 66| 1.62k| do { \ | | 67| 1.62k| assert(vstrlen(src) + 1 <= sizeof (dst)); \ | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 68| 1.62k| strcpy((dst), (src)); \ | | 69| 1.62k| } while (0) | | ------------------ | | | Branch (69:11): [Folded, False: 1.62k] | | ------------------ ------------------ 175| | 176| 1.62k| we = space; 177| 1.62k| INIT_OBJ(we, WS_EMU_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 178| 1.62k| VTAILQ_INIT(&we->head); ------------------ | | 499| 1.62k|#define VTAILQ_INIT(head) do { \ | | 500| 1.62k| VTAILQ_FIRST((head)) = NULL; \ | | ------------------ | | | | 457| 1.62k|#define VTAILQ_FIRST(head) ((head)->vtqh_first) | | ------------------ | | 501| 1.62k| (head)->vtqh_last = &VTAILQ_FIRST((head)); \ | | ------------------ | | | | 457| 1.62k|#define VTAILQ_FIRST(head) ((head)->vtqh_first) | | ------------------ | | 502| 1.62k|} while (0) | | ------------------ | | | Branch (502:10): [Folded, False: 1.62k] | | ------------------ ------------------ 179| 1.62k| we->len = len; 180| | 181| 1.62k| WS_Assert(ws); 182| 1.62k|} WS_Reset: 198| 1.62k|{ 199| 1.62k| struct ws_emu *we; 200| 1.62k| struct ws_alloc *wa; 201| 1.62k| char *p; 202| | 203| 1.62k| WS_Assert(ws); 204| 1.62k| AN(pp); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 205| 1.62k| if (pp == snap_overflowed) { ------------------ | Branch (205:6): [True: 0, False: 1.62k] ------------------ 206| 0| DSLb(DBG_WORKSPACE, "WS_Reset(%p, overflowed)", ws); ------------------ | | 622| 0| do { \ | | 623| 0| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 613| 0|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (613:21): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 624| 0| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 625| 0| } while (0) | | ------------------ | | | Branch (625:11): [Folded, False: 0] | | ------------------ ------------------ 207| 0| AN(WS_Overflowed(ws)); ------------------ | | 84| 0|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 0] | | ------------------ ------------------ 208| 0| return; 209| 0| } 210| 1.62k| p = (char *)pp; 211| 1.62k| DSLb(DBG_WORKSPACE, "WS_Reset(%p, %p)", ws, p); ------------------ | | 622| 1.62k| do { \ | | 623| 1.62k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 613| 1.62k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (613:21): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 624| 1.62k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 625| 1.62k| } while (0) | | ------------------ | | | Branch (625:11): [Folded, False: 1.62k] | | ------------------ ------------------ 212| 1.62k| AZ(ws->r); ------------------ | | 83| 1.62k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.62k] | | ------------------ ------------------ 213| | 214| 1.62k| we = ws_emu(ws); 215| 3.25k| while ((wa = VTAILQ_LAST(&we->head, ws_alloc_head)) != NULL && ------------------ | | 540| 3.25k| (*(((struct headname *)((head)->vtqh_last))->vtqh_last)) ------------------ | Branch (215:9): [True: 1.62k, False: 1.62k] ------------------ 216| 1.62k| wa->ptr != p) ------------------ | Branch (216:6): [True: 1.62k, False: 0] ------------------ 217| 1.62k| ws_alloc_free(we, &wa); 218| 1.62k| if (wa == NULL) ------------------ | Branch (218:6): [True: 1.62k, False: 0] ------------------ 219| 1.62k| assert(p == ws->s); ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 220| | 221| 1.62k| WS_Assert(ws); 222| 1.62k|} WS_Alloc: 304| 1.62k|{ 305| 1.62k| struct ws_alloc *wa; 306| | 307| 1.62k| assert(bytes > 0); ------------------ | | 65| 1.62k|#define assert(e) \ | | 66| 1.62k|do { \ | | 67| 1.62k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 1.62k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 1.62k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 1.62k] | | ------------------ ------------------ 308| 1.62k| wa = ws_emu_alloc(ws, bytes); 309| 1.62k| WS_Assert(ws); 310| 1.62k| if (wa != NULL) { ------------------ | Branch (310:6): [True: 1.62k, False: 0] ------------------ 311| 1.62k| AN(wa->ptr); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 312| 1.62k| DSLb(DBG_WORKSPACE, "WS_Alloc(%p, %u) = %p", ------------------ | | 622| 1.62k| do { \ | | 623| 1.62k| if (DO_DEBUG(debug_bit)) \ | | ------------------ | | | | 613| 1.62k|#define DO_DEBUG(x) COM_DO_DEBUG(cache_param->debug_bits, x) | | | | ------------------ | | | | | Branch (613:21): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 624| 1.62k| WRK_Log(SLT_Debug, __VA_ARGS__); \ | | 625| 1.62k| } while (0) | | ------------------ | | | Branch (625:11): [Folded, False: 1.62k] | | ------------------ ------------------ 313| 1.62k| ws, bytes, wa->ptr); 314| 1.62k| return (wa->ptr); 315| 1.62k| } 316| 0| return (NULL); 317| 1.62k|} cache_ws_emu.c:ws_emu: 67| 13.0k|{ 68| 13.0k| struct ws_emu *we; 69| | 70| 13.0k| CAST_OBJ_NOTNULL(we, (void *)ws->s, WS_EMU_MAGIC); ------------------ | | 85| 13.0k| do { \ | | 86| 13.0k| (to) = (from); \ | | 87| 13.0k| AN((to)); \ | | ------------------ | | | | 84| 13.0k|#define AN(foo) do { assert((foo) != 0); } while (0) | | | | ------------------ | | | | | | 65| 13.0k|#define assert(e) \ | | | | | | 66| 13.0k|do { \ | | | | | | 67| 13.0k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 13.0k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 13.0k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 13.0k] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (84:52): [Folded, False: 13.0k] | | | | ------------------ | | ------------------ | | 88| 13.0k| CHECK_OBJ((to), (type_magic)); \ | | ------------------ | | | | 61| 13.0k| do { \ | | | | 62| 13.0k| assert((ptr)->magic == type_magic); \ | | | | ------------------ | | | | | | 65| 13.0k|#define assert(e) \ | | | | | | 66| 13.0k|do { \ | | | | | | 67| 13.0k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 13.0k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 13.0k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 13.0k] | | | | | | ------------------ | | | | ------------------ | | | | 63| 13.0k| } while (0) | | | | ------------------ | | | | | Branch (63:11): [Folded, False: 13.0k] | | | | ------------------ | | ------------------ | | 89| 13.0k| } while (0) | | ------------------ | | | Branch (89:11): [Folded, False: 13.0k] | | ------------------ ------------------ 71| 13.0k| return (we); 72| 13.0k|} cache_ws_emu.c:ws_alloc_free: 186| 1.62k|{ 187| 1.62k| struct ws_alloc *wa; 188| | 189| 1.62k| TAKE_OBJ_NOTNULL(wa, wap, WS_ALLOC_MAGIC); ------------------ | | 92| 1.62k| do { \ | | 93| 1.62k| AN((pfrom)); \ | | ------------------ | | | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | | | ------------------ | | | | | | 65| 1.62k|#define assert(e) \ | | | | | | 66| 1.62k|do { \ | | | | | | 67| 1.62k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 1.62k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (84:52): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 94| 1.62k| (to) = *(pfrom); \ | | 95| 1.62k| *(pfrom) = NULL; \ | | 96| 1.62k| CHECK_OBJ_NOTNULL((to), (type_magic)); \ | | ------------------ | | | | 66| 1.62k| do { \ | | | | 67| 1.62k| assert((ptr) != NULL); \ | | | | ------------------ | | | | | | 65| 1.62k|#define assert(e) \ | | | | | | 66| 1.62k|do { \ | | | | | | 67| 1.62k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 1.62k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | | | ------------------ | | | | ------------------ | | | | 68| 1.62k| assert((ptr)->magic == type_magic); \ | | | | ------------------ | | | | | | 65| 1.62k|#define assert(e) \ | | | | | | 66| 1.62k|do { \ | | | | | | 67| 1.62k| if (!(e)) { \ | | | | | | ------------------ | | | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | | | ------------------ | | | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | | | 69| 0| #e, VAS_ASSERT); \ | | | | | | 70| 0| } \ | | | | | | 71| 1.62k|} while (0) | | | | | | ------------------ | | | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | | | ------------------ | | | | ------------------ | | | | 69| 1.62k| } while (0) | | | | ------------------ | | | | | Branch (69:11): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 97| 1.62k| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 1.62k] | | ------------------ ------------------ 190| 1.62k| AZ(VTAILQ_NEXT(wa, list)); ------------------ | | 83| 1.62k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.62k] | | ------------------ ------------------ 191| 1.62k| VTAILQ_REMOVE(&we->head, wa, list); ------------------ | | 547| 1.62k|#define VTAILQ_REMOVE(head, elm, field) do { \ | | 548| 1.62k| if ((VTAILQ_NEXT((elm), field)) != NULL) \ | | ------------------ | | | | 542| 1.62k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | | Branch (548:6): [True: 0, False: 1.62k] | | ------------------ | | 549| 1.62k| VTAILQ_NEXT((elm), field)->field.vtqe_prev = \ | | ------------------ | | | | 542| 0|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 550| 0| (elm)->field.vtqe_prev; \ | | 551| 1.62k| else { \ | | 552| 1.62k| (head)->vtqh_last = (elm)->field.vtqe_prev; \ | | 553| 1.62k| } \ | | 554| 1.62k| *(elm)->field.vtqe_prev = VTAILQ_NEXT((elm), field); \ | | ------------------ | | | | 542| 1.62k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 555| 1.62k| TRASHIT(*oldnext); \ | | 556| 1.62k| TRASHIT(*oldprev); \ | | 557| 1.62k|} while (0) | | ------------------ | | | Branch (557:10): [Folded, False: 1.62k] | | ------------------ ------------------ 192| 1.62k| free(wa->ptr); 193| | FREE_OBJ(wa); ------------------ | | 51| 1.62k| do { \ | | 52| 1.62k| ZERO_OBJ(&(to)->magic, sizeof (to)->magic); \ | | ------------------ | | | | 9| 1.62k| do { \ | | | | 10| 1.62k| void *(*volatile z_obj)(void *, int, size_t) = memset; \ | | | | 11| 1.62k| (void)z_obj(to, 0, sz); \ | | | | 12| 1.62k| } while (0) | | | | ------------------ | | | | | Branch (12:11): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | 53| 1.62k| free(to); \ | | 54| 1.62k| to = NULL; \ | | 55| 1.62k| } while (0) | | ------------------ | | | Branch (55:11): [Folded, False: 1.62k] | | ------------------ ------------------ 194| 1.62k|} cache_ws_emu.c:ws_emu_alloc: 269| 1.62k|{ 270| 1.62k| struct ws_emu *we; 271| 1.62k| struct ws_alloc *wa; 272| 1.62k| size_t off = 0; 273| | 274| 1.62k| WS_Assert(ws); 275| 1.62k| AZ(ws->r); ------------------ | | 83| 1.62k|#define AZ(foo) do { assert((foo) == 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (83:52): [Folded, False: 1.62k] | | ------------------ ------------------ 276| | 277| 1.62k| we = ws_emu(ws); 278| 1.62k| wa = VTAILQ_LAST(&we->head, ws_alloc_head); ------------------ | | 540| 1.62k| (*(((struct headname *)((head)->vtqh_last))->vtqh_last)) ------------------ 279| 1.62k| CHECK_OBJ_ORNULL(wa, WS_ALLOC_MAGIC); ------------------ | | 72| 1.62k| do { \ | | 73| 1.62k| if ((ptr) != NULL) \ | | ------------------ | | | Branch (73:7): [True: 0, False: 1.62k] | | ------------------ | | 74| 1.62k| assert((ptr)->magic == type_magic); \ | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 75| 1.62k| } while (0) | | ------------------ | | | Branch (75:11): [Folded, False: 1.62k] | | ------------------ ------------------ 280| | 281| 1.62k| if (wa != NULL) ------------------ | Branch (281:6): [True: 0, False: 1.62k] ------------------ 282| 0| off = wa->off + PRNDUP(wa->len); ------------------ | | 153| 0|#define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ | | #define PRNDUP(p) (((uintptr_t)(p) + PALGN) & ~PALGN) /* Round up */ | | ------------------ | | | | 149| 0|# define PALGN (sizeof(void *) - 1) /* size of alignment */ | | ------------------ ------------------ 283| 1.62k| if (off + len > we->len) { ------------------ | Branch (283:6): [True: 0, False: 1.62k] ------------------ 284| 0| WS_MarkOverflow(ws); 285| 0| return (NULL); 286| 0| } 287| 1.62k| if (len == 0) ------------------ | Branch (287:6): [True: 0, False: 1.62k] ------------------ 288| 0| len = we->len - off; 289| | 290| 1.62k| ALLOC_OBJ(wa, WS_ALLOC_MAGIC); ------------------ | | 27| 1.62k| do { \ | | 28| 1.62k| (to) = calloc((size_t)1, sizeof *(to)); \ | | 29| 1.62k| if ((to) != NULL) \ | | ------------------ | | | Branch (29:7): [True: 1.62k, False: 0] | | ------------------ | | 30| 1.62k| (to)->magic = (type_magic); \ | | 31| 1.62k| } while (0) | | ------------------ | | | Branch (31:11): [Folded, False: 1.62k] | | ------------------ ------------------ 291| 1.62k| AN(wa); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 292| 1.62k| wa->off = off; 293| 1.62k| wa->len = len; 294| 1.62k| if (len > 0) { ------------------ | Branch (294:6): [True: 1.62k, False: 0] ------------------ 295| 1.62k| wa->ptr = malloc(len); 296| 1.62k| AN(wa->ptr); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 297| 1.62k| } 298| 1.62k| VTAILQ_INSERT_TAIL(&we->head, wa, list); ------------------ | | 532| 1.62k|#define VTAILQ_INSERT_TAIL(head, elm, field) do { \ | | 533| 1.62k| VTAILQ_NEXT((elm), field) = NULL; \ | | ------------------ | | | | 542| 1.62k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 534| 1.62k| (elm)->field.vtqe_prev = (head)->vtqh_last; \ | | 535| 1.62k| *(head)->vtqh_last = (elm); \ | | 536| 1.62k| (head)->vtqh_last = &VTAILQ_NEXT((elm), field); \ | | ------------------ | | | | 542| 1.62k|#define VTAILQ_NEXT(elm, field) ((elm)->field.vtqe_next) | | ------------------ | | 537| 1.62k|} while (0) | | ------------------ | | | Branch (537:10): [Folded, False: 1.62k] | | ------------------ ------------------ 299| 1.62k| return (wa); 300| 1.62k|} cache_ws_emu.c:COM_DO_DEBUG: 51| 14.6k|{ 52| 14.6k| return ((p[(unsigned)x>>3] & (0x80U >> ((unsigned)x & 7))) != 0); 53| 14.6k|} VSLb: 76| 33.4k|{ 77| 33.4k| (void)vsl; 78| 33.4k| (void)tag; 79| 33.4k| (void)fmt; 80| 33.4k|} LLVMFuzzerTestOneInput: 121| 1.62k|{ 122| 1.62k| struct VSC_main __VSC_C_main; 123| 1.62k| struct params __cache_param; 124| 1.62k| struct http req[1]; 125| 1.62k| struct http resp[1]; 126| 1.62k| struct vfp_ctx vc[1]; 127| 1.62k| struct worker wrk[1]; 128| 1.62k| struct ws ws[1]; 129| 1.62k| struct vep_state *vep; 130| 1.62k| struct vsb *vsb; 131| 1.62k| txt hd[HTTP_HDR_URL + 1]; 132| 1.62k| struct vep_flags flags = {0}; 133| 1.62k| char ws_buf[1024]; 134| | 135| 1.62k| if (size < 1) ------------------ | Branch (135:6): [True: 0, False: 1.62k] ------------------ 136| 0| return (0); 137| | 138| 1.62k| AN(data); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 139| | 140| 1.62k| VSC_C_main = &__VSC_C_main; 141| 1.62k| cache_param = &__cache_param; 142| | 143| 1.62k| memset(&__cache_param, 0, sizeof(__cache_param)); 144| 1.62k| if (data[0] & 0x8f) ------------------ | Branch (144:6): [True: 1.58k, False: 41] ------------------ 145| 1.58k| flags.esi_ignore_https = 1; 146| 1.62k| if (size > 1 && data[1] & 0x8f) ------------------ | Branch (146:6): [True: 1.59k, False: 29] | Branch (146:18): [True: 1.54k, False: 51] ------------------ 147| 1.54k| flags.esi_disable_xml_check = 1; 148| 1.62k| if (size > 2 && data[2] & 0x8f) ------------------ | Branch (148:6): [True: 1.57k, False: 55] | Branch (148:18): [True: 1.51k, False: 62] ------------------ 149| 1.51k| flags.esi_ignore_other_elements = 1; 150| 1.62k| if (size > 3 && data[3] & 0x8f) ------------------ | Branch (150:6): [True: 1.55k, False: 70] | Branch (150:18): [True: 1.50k, False: 48] ------------------ 151| 1.50k| flags.esi_remove_bom = 1; 152| | 153| | /* Setup ws */ 154| 1.62k| WS_Init(ws, "req", ws_buf, sizeof ws_buf); 155| | 156| | /* Setup req */ 157| 1.62k| INIT_OBJ(req, HTTP_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 158| 1.62k| req->hd = hd; 159| 1.62k| req->hd[HTTP_HDR_URL].b = "/"; 160| 1.62k| req->ws = ws; 161| | 162| | /* Setup resp */ 163| 1.62k| INIT_OBJ(resp, HTTP_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 164| 1.62k| resp->ws = ws; 165| | 166| | /* Setup wrk */ 167| 1.62k| INIT_OBJ(wrk, WORKER_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 168| | 169| | /* Setup vc */ 170| 1.62k| INIT_OBJ(vc, VFP_CTX_MAGIC); ------------------ | | 15| 1.62k| do { \ | | 16| 1.62k| (void)memset(to, 0, sizeof *(to)); \ | | 17| 1.62k| (to)->magic = (type_magic); \ | | 18| 1.62k| } while (0) | | ------------------ | | | Branch (18:11): [Folded, False: 1.62k] | | ------------------ ------------------ 171| 1.62k| vc->wrk = wrk; 172| 1.62k| vc->resp = resp; 173| | 174| 1.62k| vep = VEP_Init(vc, req, NULL, NULL, flags); 175| | 176| 1.62k| AN(vep); ------------------ | | 84| 1.62k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 1.62k|#define assert(e) \ | | | | 66| 1.62k|do { \ | | | | 67| 1.62k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 1.62k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 1.62k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 1.62k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 1.62k] | | ------------------ ------------------ 177| 1.62k| VEP_Parse(vep, (const char *)data, size); 178| 1.62k| vsb = VEP_Finish(vep); 179| 1.62k| if (vsb != NULL) ------------------ | Branch (179:6): [True: 1.12k, False: 498] ------------------ 180| 1.12k| VSB_destroy(&vsb); 181| 1.62k| WS_Rollback(ws, 0); 182| | 183| 1.62k| return (0); 184| 1.62k|} cache_ws_emu.c:pdiff: 143| 9.76k|{ 144| | 145| 9.76k| AN(b); ------------------ | | 84| 9.76k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 9.76k|#define assert(e) \ | | | | 66| 9.76k|do { \ | | | | 67| 9.76k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.76k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.76k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.76k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 9.76k] | | ------------------ ------------------ 146| 9.76k| AN(e); ------------------ | | 84| 9.76k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 9.76k|#define assert(e) \ | | | | 66| 9.76k|do { \ | | | | 67| 9.76k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 9.76k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 9.76k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 9.76k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 9.76k] | | ------------------ ------------------ 147| 9.76k| assert(b <= e); ------------------ | | 65| 9.76k|#define assert(e) \ | | 66| 9.76k|do { \ | | 67| 9.76k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 9.76k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 9.76k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 9.76k] | | ------------------ ------------------ 148| 9.76k| return ((size_t)((const char *)e - (const char *)b)); 149| 9.76k|} cache_esi_parse.c:vct_is: 63| 26.1M|{ 64| | 65| 26.1M| x &= 0xff; 66| 26.1M| return (vct_typtab[x] & (y)); 67| 26.1M|} cache_esi_parse.c:vbe16enc: 93| 1.25k|{ 94| 1.25k| uint8_t *p = (uint8_t *)pp; 95| | 96| 1.25k| p[0] = (u >> 8) & 0xff; 97| 1.25k| p[1] = u & 0xff; 98| 1.25k|} cache_esi_parse.c:vbe16dec: 41| 1.25k|{ 42| 1.25k| uint8_t const *p = (uint8_t const *)pp; 43| | 44| 1.25k| return ((p[0] << 8) | p[1]); 45| 1.25k|} cache_esi_parse.c:vbe64enc: 113| 170|{ 114| 170| uint8_t *p = (uint8_t *)pp; 115| | 116| 170| vbe32enc(p, (uint32_t)(u >> 32)); 117| 170| vbe32enc(p + 4, (uint32_t)(u & 0xffffffffU)); 118| 170|} cache_esi_parse.c:vbe32enc: 102| 340|{ 103| 340| uint8_t *p = (uint8_t *)pp; 104| | 105| 340| p[0] = (u >> 24) & 0xff; 106| 340| p[1] = (u >> 16) & 0xff; 107| 340| p[2] = (u >> 8) & 0xff; 108| 340| p[3] = u & 0xff; 109| 340|} cache_esi_parse.c:vbe64dec: 57| 170|{ 58| 170| uint8_t const *p = (uint8_t const *)pp; 59| | 60| 170| return (((uint64_t)vbe32dec(p) << 32) | vbe32dec(p + 4)); 61| 170|} cache_esi_parse.c:vbe32dec: 49| 340|{ 50| 340| uint8_t const *p = (uint8_t const *)pp; 51| | 52| 340| return (((unsigned)p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]); 53| 340|} z_crc32_z: 695| 447k| z_size_t len) { 696| | /* Return initial CRC, if requested. */ 697| 447k| if (buf == Z_NULL) return 0; ------------------ | | 217| 447k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (697:9): [True: 175k, False: 271k] ------------------ 698| | 699| |#ifdef DYNAMIC_CRC_TABLE 700| | once(&made, make_crc_table); 701| |#endif /* DYNAMIC_CRC_TABLE */ 702| | 703| | /* Pre-condition the CRC */ 704| 271k| crc = (~crc) & 0xffffffff; 705| | 706| 271k|#ifdef W 707| | 708| | /* If provided enough bytes, do a braided CRC calculation. */ 709| 271k| if (len >= N * W + W - 1) { ------------------ | | 57| 271k|# define N 5 ------------------ if (len >= N * W + W - 1) { ------------------ | | 83| 271k|# define W 8 ------------------ if (len >= N * W + W - 1) { ------------------ | | 83| 271k|# define W 8 ------------------ | Branch (709:9): [True: 15.6k, False: 256k] ------------------ 710| 15.6k| z_size_t blks; 711| 15.6k| z_word_t const *words; 712| 15.6k| unsigned endian; 713| 15.6k| int k; 714| | 715| | /* Compute the CRC up to a z_word_t boundary. */ 716| 69.0k| while (len && ((z_size_t)buf & (W - 1)) != 0) { ------------------ | | 83| 69.0k|# define W 8 ------------------ | Branch (716:16): [True: 69.0k, False: 0] | Branch (716:23): [True: 53.3k, False: 15.6k] ------------------ 717| 53.3k| len--; 718| 53.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 719| 53.3k| } 720| | 721| | /* Compute the CRC on as many N z_word_t blocks as are available. */ 722| 15.6k| blks = len / (N * W); ------------------ | | 57| 15.6k|# define N 5 ------------------ blks = len / (N * W); ------------------ | | 83| 15.6k|# define W 8 ------------------ 723| 15.6k| len -= blks * N * W; ------------------ | | 57| 15.6k|# define N 5 ------------------ len -= blks * N * W; ------------------ | | 83| 15.6k|# define W 8 ------------------ 724| 15.6k| words = (z_word_t const *)(intptr_t)buf; 725| | 726| | /* Do endian check at execution time instead of compile time, since ARM 727| | processors can change the endianness at execution time. If the 728| | compiler knows what the endianness will be, it can optimize out the 729| | check and the unused branch. */ 730| 15.6k| endian = 1; 731| 15.6k| if (*(unsigned char *)&endian) { ------------------ | Branch (731:13): [True: 15.6k, False: 0] ------------------ 732| | /* Little endian. */ 733| | 734| 15.6k| z_crc_t crc0; 735| 15.6k| z_word_t word0; 736| 15.6k|#if N > 1 737| 15.6k| z_crc_t crc1; 738| 15.6k| z_word_t word1; 739| 15.6k|#if N > 2 740| 15.6k| z_crc_t crc2; 741| 15.6k| z_word_t word2; 742| 15.6k|#if N > 3 743| 15.6k| z_crc_t crc3; 744| 15.6k| z_word_t word3; 745| 15.6k|#if N > 4 746| 15.6k| z_crc_t crc4; 747| 15.6k| z_word_t word4; 748| |#if N > 5 749| | z_crc_t crc5; 750| | z_word_t word5; 751| |#endif 752| 15.6k|#endif 753| 15.6k|#endif 754| 15.6k|#endif 755| 15.6k|#endif 756| | 757| | /* Initialize the CRC for each braid. */ 758| 15.6k| crc0 = crc; 759| 15.6k|#if N > 1 760| 15.6k| crc1 = 0; 761| 15.6k|#if N > 2 762| 15.6k| crc2 = 0; 763| 15.6k|#if N > 3 764| 15.6k| crc3 = 0; 765| 15.6k|#if N > 4 766| 15.6k| crc4 = 0; 767| |#if N > 5 768| | crc5 = 0; 769| |#endif 770| 15.6k|#endif 771| 15.6k|#endif 772| 15.6k|#endif 773| 15.6k|#endif 774| | 775| | /* 776| | Process the first blks-1 blocks, computing the CRCs on each braid 777| | independently. 778| | */ 779| 1.32M| while (--blks) { ------------------ | Branch (779:20): [True: 1.31M, False: 15.6k] ------------------ 780| | /* Load the word for each braid into registers. */ 781| 1.31M| word0 = crc0 ^ words[0]; 782| 1.31M|#if N > 1 783| 1.31M| word1 = crc1 ^ words[1]; 784| 1.31M|#if N > 2 785| 1.31M| word2 = crc2 ^ words[2]; 786| 1.31M|#if N > 3 787| 1.31M| word3 = crc3 ^ words[3]; 788| 1.31M|#if N > 4 789| 1.31M| word4 = crc4 ^ words[4]; 790| |#if N > 5 791| | word5 = crc5 ^ words[5]; 792| |#endif 793| 1.31M|#endif 794| 1.31M|#endif 795| 1.31M|#endif 796| 1.31M|#endif 797| 1.31M| words += N; ------------------ | | 57| 1.31M|# define N 5 ------------------ 798| | 799| | /* Compute and update the CRC for each word. The loop should 800| | get unrolled. */ 801| 1.31M| crc0 = crc_braid_table[0][word0 & 0xff]; 802| 1.31M|#if N > 1 803| 1.31M| crc1 = crc_braid_table[0][word1 & 0xff]; 804| 1.31M|#if N > 2 805| 1.31M| crc2 = crc_braid_table[0][word2 & 0xff]; 806| 1.31M|#if N > 3 807| 1.31M| crc3 = crc_braid_table[0][word3 & 0xff]; 808| 1.31M|#if N > 4 809| 1.31M| crc4 = crc_braid_table[0][word4 & 0xff]; 810| |#if N > 5 811| | crc5 = crc_braid_table[0][word5 & 0xff]; 812| |#endif 813| 1.31M|#endif 814| 1.31M|#endif 815| 1.31M|#endif 816| 1.31M|#endif 817| 10.4M| for (k = 1; k < W; k++) { ------------------ | | 83| 10.4M|# define W 8 ------------------ | Branch (817:29): [True: 9.18M, False: 1.31M] ------------------ 818| 9.18M| crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff]; 819| 9.18M|#if N > 1 820| 9.18M| crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff]; 821| 9.18M|#if N > 2 822| 9.18M| crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff]; 823| 9.18M|#if N > 3 824| 9.18M| crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff]; 825| 9.18M|#if N > 4 826| 9.18M| crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff]; 827| |#if N > 5 828| | crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff]; 829| |#endif 830| 9.18M|#endif 831| 9.18M|#endif 832| 9.18M|#endif 833| 9.18M|#endif 834| 9.18M| } 835| 1.31M| } 836| | 837| | /* 838| | Process the last block, combining the CRCs of the N braids at the 839| | same time. 840| | */ 841| 15.6k| crc = crc_word(crc0 ^ words[0]); 842| 15.6k|#if N > 1 843| 15.6k| crc = crc_word(crc1 ^ words[1] ^ crc); 844| 15.6k|#if N > 2 845| 15.6k| crc = crc_word(crc2 ^ words[2] ^ crc); 846| 15.6k|#if N > 3 847| 15.6k| crc = crc_word(crc3 ^ words[3] ^ crc); 848| 15.6k|#if N > 4 849| 15.6k| crc = crc_word(crc4 ^ words[4] ^ crc); 850| |#if N > 5 851| | crc = crc_word(crc5 ^ words[5] ^ crc); 852| |#endif 853| 15.6k|#endif 854| 15.6k|#endif 855| 15.6k|#endif 856| 15.6k|#endif 857| 15.6k| words += N; ------------------ | | 57| 15.6k|# define N 5 ------------------ 858| 15.6k| } 859| 0| else { 860| | /* Big endian. */ 861| | 862| 0| z_word_t crc0, word0, comb; 863| 0|#if N > 1 864| 0| z_word_t crc1, word1; 865| 0|#if N > 2 866| 0| z_word_t crc2, word2; 867| 0|#if N > 3 868| 0| z_word_t crc3, word3; 869| 0|#if N > 4 870| 0| z_word_t crc4, word4; 871| |#if N > 5 872| | z_word_t crc5, word5; 873| |#endif 874| 0|#endif 875| 0|#endif 876| 0|#endif 877| 0|#endif 878| | 879| | /* Initialize the CRC for each braid. */ 880| 0| crc0 = byte_swap(crc); 881| 0|#if N > 1 882| 0| crc1 = 0; 883| 0|#if N > 2 884| 0| crc2 = 0; 885| 0|#if N > 3 886| 0| crc3 = 0; 887| 0|#if N > 4 888| 0| crc4 = 0; 889| |#if N > 5 890| | crc5 = 0; 891| |#endif 892| 0|#endif 893| 0|#endif 894| 0|#endif 895| 0|#endif 896| | 897| | /* 898| | Process the first blks-1 blocks, computing the CRCs on each braid 899| | independently. 900| | */ 901| 0| while (--blks) { ------------------ | Branch (901:20): [True: 0, False: 0] ------------------ 902| | /* Load the word for each braid into registers. */ 903| 0| word0 = crc0 ^ words[0]; 904| 0|#if N > 1 905| 0| word1 = crc1 ^ words[1]; 906| 0|#if N > 2 907| 0| word2 = crc2 ^ words[2]; 908| 0|#if N > 3 909| 0| word3 = crc3 ^ words[3]; 910| 0|#if N > 4 911| 0| word4 = crc4 ^ words[4]; 912| |#if N > 5 913| | word5 = crc5 ^ words[5]; 914| |#endif 915| 0|#endif 916| 0|#endif 917| 0|#endif 918| 0|#endif 919| 0| words += N; ------------------ | | 57| 0|# define N 5 ------------------ 920| | 921| | /* Compute and update the CRC for each word. The loop should 922| | get unrolled. */ 923| 0| crc0 = crc_braid_big_table[0][word0 & 0xff]; 924| 0|#if N > 1 925| 0| crc1 = crc_braid_big_table[0][word1 & 0xff]; 926| 0|#if N > 2 927| 0| crc2 = crc_braid_big_table[0][word2 & 0xff]; 928| 0|#if N > 3 929| 0| crc3 = crc_braid_big_table[0][word3 & 0xff]; 930| 0|#if N > 4 931| 0| crc4 = crc_braid_big_table[0][word4 & 0xff]; 932| |#if N > 5 933| | crc5 = crc_braid_big_table[0][word5 & 0xff]; 934| |#endif 935| 0|#endif 936| 0|#endif 937| 0|#endif 938| 0|#endif 939| 0| for (k = 1; k < W; k++) { ------------------ | | 83| 0|# define W 8 ------------------ | Branch (939:29): [True: 0, False: 0] ------------------ 940| 0| crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff]; 941| 0|#if N > 1 942| 0| crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff]; 943| 0|#if N > 2 944| 0| crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff]; 945| 0|#if N > 3 946| 0| crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff]; 947| 0|#if N > 4 948| 0| crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff]; 949| |#if N > 5 950| | crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff]; 951| |#endif 952| 0|#endif 953| 0|#endif 954| 0|#endif 955| 0|#endif 956| 0| } 957| 0| } 958| | 959| | /* 960| | Process the last block, combining the CRCs of the N braids at the 961| | same time. 962| | */ 963| 0| comb = crc_word_big(crc0 ^ words[0]); 964| 0|#if N > 1 965| 0| comb = crc_word_big(crc1 ^ words[1] ^ comb); 966| 0|#if N > 2 967| 0| comb = crc_word_big(crc2 ^ words[2] ^ comb); 968| 0|#if N > 3 969| 0| comb = crc_word_big(crc3 ^ words[3] ^ comb); 970| 0|#if N > 4 971| 0| comb = crc_word_big(crc4 ^ words[4] ^ comb); 972| |#if N > 5 973| | comb = crc_word_big(crc5 ^ words[5] ^ comb); 974| |#endif 975| 0|#endif 976| 0|#endif 977| 0|#endif 978| 0|#endif 979| 0| words += N; ------------------ | | 57| 0|# define N 5 ------------------ 980| 0| crc = byte_swap(comb); 981| 0| } 982| | 983| | /* 984| | Update the pointer to the remaining bytes to process. 985| | */ 986| 15.6k| buf = (unsigned char const *)words; 987| 15.6k| } 988| | 989| 271k|#endif /* W */ 990| | 991| | /* Complete the computation of the CRC on any remaining bytes. */ 992| 345k| while (len >= 8) { ------------------ | Branch (992:12): [True: 73.3k, False: 271k] ------------------ 993| 73.3k| len -= 8; 994| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 995| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 996| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 997| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 998| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 999| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1000| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1001| 73.3k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1002| 73.3k| } 1003| 1.11M| while (len) { ------------------ | Branch (1003:12): [True: 847k, False: 271k] ------------------ 1004| 847k| len--; 1005| 847k| crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff]; 1006| 847k| } 1007| | 1008| | /* Return the CRC, post-conditioned. */ 1009| 271k| return crc ^ 0xffffffff; 1010| 447k|} z_crc32: 1016| 447k| uInt len) { 1017| 447k| return crc32_z(crc, buf, len); ------------------ | | 44| 447k|# define crc32_z z_crc32_z ------------------ 1018| 447k|} z_crc32_combine64: 1021| 156|uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) { 1022| |#ifdef DYNAMIC_CRC_TABLE 1023| | once(&made, make_crc_table); 1024| |#endif /* DYNAMIC_CRC_TABLE */ 1025| 156| return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff); 1026| 156|} z_crc32_combine: 1029| 156|uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) { 1030| 156| return crc32_combine64(crc1, crc2, (z_off64_t)len2); ------------------ | | 40| 156|# define crc32_combine64 z_crc32_combine64 ------------------ 1031| 156|} crc32.c:crc_word: 676| 78.3k|local z_crc_t crc_word (z_word_t data) { 677| 78.3k| int k; 678| 705k| for (k = 0; k < W; k++) ------------------ | | 83| 705k|# define W 8 ------------------ | Branch (678:17): [True: 626k, False: 78.3k] ------------------ 679| 626k| data = (data >> 8) ^ crc_table[data & 0xff]; 680| 78.3k| return (z_crc_t)data; 681| 78.3k|} crc32.c:multmodp: 155| 764|local z_crc_t multmodp(z_crc_t a, z_crc_t b) { 156| 764| z_crc_t m, p; 157| | 158| 764| m = (z_crc_t)1 << 31; 159| 764| p = 0; 160| 18.0k| for (;;) { 161| 18.0k| if (a & m) { ------------------ | Branch (161:13): [True: 8.06k, False: 9.96k] ------------------ 162| 8.06k| p ^= b; 163| 8.06k| if ((a & (m - 1)) == 0) ------------------ | Branch (163:17): [True: 764, False: 7.30k] ------------------ 164| 764| break; 165| 8.06k| } 166| 17.2k| m >>= 1; 167| 17.2k| b = b & 1 ? (b >> 1) ^ POLY : b >> 1; ------------------ | | 149| 7.35k|#define POLY 0xedb88320 /* p(x) reflected, with x^32 implied */ ------------------ | Branch (167:13): [True: 7.35k, False: 9.91k] ------------------ 168| 17.2k| } 169| 764| return p; 170| 764|} crc32.c:x2nmodp: 176| 156|local z_crc_t x2nmodp(z_off64_t n, unsigned k) { 177| 156| z_crc_t p; 178| | 179| 156| p = (z_crc_t)1 << 31; /* x^0 == 1 */ 180| 924| while (n) { ------------------ | Branch (180:12): [True: 768, False: 156] ------------------ 181| 768| if (n & 1) ------------------ | Branch (181:13): [True: 608, False: 160] ------------------ 182| 608| p = multmodp(x2n_table[k & 31], p); 183| 768| n >>= 1; 184| 768| k++; 185| 768| } 186| 156| return p; 187| 156|} VSB_new_auto: 227| 13.1k|{ 228| 13.1k| struct vsb *s; 229| | 230| 13.1k| s = SBMALLOC(sizeof(*s)); ------------------ | | 47| 13.1k|#define SBMALLOC(size) malloc(size) ------------------ 231| 13.1k| if (s == NULL) ------------------ | Branch (231:6): [True: 0, False: 13.1k] ------------------ 232| 0| return (NULL); 233| 13.1k| if (VSB_newbuf(s, NULL, 0, VSB_AUTOEXTEND) == NULL) { ------------------ | | 47| 13.1k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ ------------------ | Branch (233:6): [True: 0, False: 13.1k] ------------------ 234| 0| SBFREE(s); ------------------ | | 48| 0|#define SBFREE(buf) free(buf) ------------------ 235| 0| return (NULL); 236| 0| } 237| 13.1k| VSB_SETFLAG(s, VSB_DYNSTRUCT); ------------------ | | 64| 13.1k|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 13.1k] | | ------------------ ------------------ 238| 13.1k| return (s); 239| 13.1k|} VSB_bcat: 286| 171k|{ 287| 171k| assert_VSB_integrity(s); ------------------ | | 108| 171k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 288| 171k| assert_VSB_state(s, 0); ------------------ | | 109| 171k|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 289| | 290| 171k| assert(len >= 0); ------------------ | | 65| 171k|#define assert(e) \ | | 66| 171k|do { \ | | 67| 171k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 171k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 171k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 171k] | | ------------------ ------------------ 291| 171k| if (s->s_error != 0) ------------------ | Branch (291:6): [True: 0, False: 171k] ------------------ 292| 0| return (-1); 293| 171k| if (len == 0) ------------------ | Branch (293:6): [True: 0, False: 171k] ------------------ 294| 0| return (0); 295| 171k| _vsb_indent(s); 296| 171k| if (len > VSB_FREESPACE(s)) { ------------------ | | 58| 171k|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (296:6): [True: 816, False: 171k] ------------------ 297| 816| if (VSB_extend(s, len - VSB_FREESPACE(s)) < 0) ------------------ | | 58| 816|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (297:7): [True: 0, False: 816] ------------------ 298| 0| s->s_error = ENOMEM; 299| 816| if (s->s_error != 0) ------------------ | Branch (299:7): [True: 0, False: 816] ------------------ 300| 0| return (-1); 301| 816| } 302| 171k| vmemcpy(s->s_buf + s->s_len, buf, len); ------------------ | | 375| 171k|# define vmemcpy(d, s, n) __builtin_memcpy(d, s, n) ------------------ 303| 171k| s->s_len += len; 304| 171k| return (0); 305| 171k|} VSB_vprintf: 340| 4.73M|{ 341| 4.73M| va_list ap_copy; 342| 4.73M| int len; 343| | 344| 4.73M| assert_VSB_integrity(s); ------------------ | | 108| 4.73M|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 345| 4.73M| assert_VSB_state(s, 0); ------------------ | | 109| 4.73M|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 346| | 347| 4.73M| KASSERT(fmt != NULL, ------------------ | | 46| 4.73M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 4.73M|#define assert(e) \ | | | | 66| 4.73M|do { \ | | | | 67| 4.73M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.73M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.73M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.73M] | | | | ------------------ | | ------------------ ------------------ 348| 4.73M| ("%s called with a NULL format string", __func__)); 349| | 350| 4.73M| if (s->s_error != 0) ------------------ | Branch (350:6): [True: 0, False: 4.73M] ------------------ 351| 0| return (-1); 352| 4.73M| _vsb_indent(s); 353| | 354| | /* 355| | * For the moment, there is no way to get vsnprintf(3) to hand 356| | * back a character at a time, to push everything into 357| | * VSB_putc_func() as was done for the kernel. 358| | * 359| | * In userspace, while drains are useful, there's generally 360| | * not a problem attempting to malloc(3) on out of space. So 361| | * expand a userland vsb if there is not enough room for the 362| | * data produced by VSB_[v]printf(3). 363| | */ 364| | 365| 4.73M| do { 366| 4.73M| va_copy(ap_copy, ap); 367| 4.73M| len = vsnprintf(&s->s_buf[s->s_len], VSB_FREESPACE(s) + 1, ------------------ | | 58| 4.73M|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ 368| 4.73M| fmt, ap_copy); 369| 4.73M| va_end(ap_copy); 370| 4.73M| if (len < 0) { ------------------ | Branch (370:7): [True: 0, False: 4.73M] ------------------ 371| 0| s->s_error = errno; 372| 0| return (-1); 373| 0| } 374| 4.73M| } while (len > VSB_FREESPACE(s) && ------------------ | | 58| 9.47M|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (374:11): [True: 2.18k, False: 4.73M] ------------------ 375| 2.18k| VSB_extend(s, len - VSB_FREESPACE(s)) == 0); ------------------ | | 58| 2.18k|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (375:6): [True: 2.18k, False: 0] ------------------ 376| | 377| | /* 378| | * s->s_len is the length of the string, without the terminating nul. 379| | * When updating s->s_len, we must subtract 1 from the length that 380| | * we passed into vsnprintf() because that length includes the 381| | * terminating nul. 382| | * 383| | * vsnprintf() returns the amount that would have been copied, 384| | * given sufficient space, so don't over-increment s_len. 385| | */ 386| 4.73M| s->s_len += vmin_t(ssize_t, len, VSB_FREESPACE(s)); ------------------ | | 206| 4.73M|#define vmin_t(type, a, b) vtake(min, type, type, a, b) | | ------------------ | | | | 200| 4.73M|#define vtake(n, ta, tb, a, b) _vtake(op ## n, ta, tb, a, b, \ | | | | ------------------ | | | | | | 191| 4.73M| ({ \ | | | | | | 192| 4.73M| ta _va = (a); \ | | | | | | 193| 4.73M| tb _vb = (b); \ | | | | | | 194| 4.73M| (void)(&_va == &_vb); \ | | | | | | 195| 4.73M| _va op _vb ? _va : _vb; \ | | | | | | ------------------ | | | | | | | Branch (195:2): [True: 4.73M, False: 2.07k] | | | | | | ------------------ | | | | | | 196| 4.73M|}) | | | | ------------------ | | | | 201| 4.73M| VUNIQ_NAME(_v ## n ## A), VUNIQ_NAME(_v ## n ## B)) | | ------------------ ------------------ 387| 4.73M| if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s)) ------------------ | | 57| 9.47M|#define VSB_HASROOM(s) ((s)->s_len < (s)->s_size - 1L) ------------------ if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s)) ------------------ | | 59| 2.07k|#define VSB_CANEXTEND(s) ((s)->s_flags & VSB_AUTOEXTEND) | | ------------------ | | | | 47| 2.07k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ | | ------------------ ------------------ | Branch (387:6): [True: 2.07k, False: 4.73M] | Branch (387:25): [True: 0, False: 2.07k] ------------------ 388| 0| s->s_error = ENOMEM; 389| | 390| 4.73M| KASSERT(s->s_len < s->s_size, ------------------ | | 46| 4.73M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 4.73M|#define assert(e) \ | | | | 66| 4.73M|do { \ | | | | 67| 4.73M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 4.73M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 4.73M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 4.73M] | | | | ------------------ | | ------------------ ------------------ 391| 4.73M| ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size)); 392| | 393| 4.73M| if (s->s_error != 0) ------------------ | Branch (393:6): [True: 0, False: 4.73M] ------------------ 394| 0| return (-1); 395| 4.73M| return (0); 396| 4.73M|} VSB_printf: 403| 4.73M|{ 404| 4.73M| va_list ap; 405| 4.73M| int result; 406| | 407| 4.73M| va_start(ap, fmt); 408| 4.73M| result = VSB_vprintf(s, fmt, ap); 409| | va_end(ap); 410| 4.73M| return (result); 411| 4.73M|} VSB_putc: 418| 15.1M|{ 419| | 420| 15.1M| VSB_put_byte(s, c); 421| 15.1M| if (s->s_error != 0) ------------------ | Branch (421:6): [True: 0, False: 15.1M] ------------------ 422| 0| return (-1); 423| 15.1M| return (0); 424| 15.1M|} VSB_finish: 441| 11.9k|{ 442| | 443| 11.9k| assert_VSB_integrity(s); ------------------ | | 108| 11.9k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 444| 11.9k| assert_VSB_state(s, 0); ------------------ | | 109| 11.9k|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 445| | 446| 11.9k| s->s_buf[s->s_len] = '\0'; 447| 11.9k| VSB_SETFLAG(s, VSB_FINISHED); ------------------ | | 64| 11.9k|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 11.9k] | | ------------------ ------------------ 448| 11.9k| errno = s->s_error; 449| 11.9k| if (s->s_error) ------------------ | Branch (449:6): [True: 0, False: 11.9k] ------------------ 450| 0| return (-1); 451| 11.9k| return (0); 452| 11.9k|} VSB_data: 459| 20.2k|{ 460| | 461| 20.2k| assert_VSB_integrity(s); ------------------ | | 108| 20.2k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 462| 20.2k| assert_VSB_state(s, VSB_FINISHED); ------------------ | | 109| 20.2k|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 463| | 464| 20.2k| return (s->s_buf); 465| 20.2k|} VSB_len: 472| 8.37k|{ 473| | 474| 8.37k| assert_VSB_integrity(s); ------------------ | | 108| 8.37k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 475| | /* don't care if it's finished or not */ 476| | 477| 8.37k| if (s->s_error != 0) ------------------ | Branch (477:6): [True: 0, False: 8.37k] ------------------ 478| 0| return (-1); 479| 8.37k| return (s->s_len); 480| 8.37k|} VSB_destroy: 494| 13.1k|{ 495| | 496| 13.1k| AN(s); ------------------ | | 84| 13.1k|#define AN(foo) do { assert((foo) != 0); } while (0) | | ------------------ | | | | 65| 13.1k|#define assert(e) \ | | | | 66| 13.1k|do { \ | | | | 67| 13.1k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 13.1k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 13.1k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 13.1k] | | | | ------------------ | | ------------------ | | | Branch (84:52): [Folded, False: 13.1k] | | ------------------ ------------------ 497| 13.1k| assert_VSB_integrity(*s); ------------------ | | 108| 13.1k|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 498| 13.1k| assert(VSB_ISDYNAMIC(*s)); ------------------ | | 65| 13.1k|#define assert(e) \ | | 66| 13.1k|do { \ | | 67| 13.1k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 13.1k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 13.1k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 13.1k] | | ------------------ ------------------ 499| 13.1k| assert(VSB_ISDYNSTRUCT(*s)); ------------------ | | 65| 13.1k|#define assert(e) \ | | 66| 13.1k|do { \ | | 67| 13.1k| if (!(e)) { \ | | ------------------ | | | Branch (67:6): [True: 0, False: 13.1k] | | ------------------ | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | 69| 0| #e, VAS_ASSERT); \ | | 70| 0| } \ | | 71| 13.1k|} while (0) | | ------------------ | | | Branch (71:10): [Folded, False: 13.1k] | | ------------------ ------------------ 500| 13.1k| SBFREE((*s)->s_buf); ------------------ | | 48| 13.1k|#define SBFREE(buf) free(buf) ------------------ 501| 13.1k| memset(*s, 0, sizeof(**s)); 502| 13.1k| SBFREE(*s); ------------------ | | 48| 13.1k|#define SBFREE(buf) free(buf) ------------------ 503| | *s = NULL; 504| 13.1k|} vsb.c:VSB_newbuf: 185| 13.1k|{ 186| | 187| 13.1k| memset(s, 0, sizeof(*s)); 188| 13.1k| s->magic = VSB_MAGIC; ------------------ | | 41| 13.1k|#define VSB_MAGIC 0x4a82dd8a ------------------ 189| 13.1k| s->s_flags = flags; 190| 13.1k| s->s_size = length; 191| 13.1k| s->s_buf = buf; 192| | 193| 13.1k| if ((s->s_flags & VSB_AUTOEXTEND) == 0) { ------------------ | | 47| 13.1k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ ------------------ | Branch (193:6): [True: 0, False: 13.1k] ------------------ 194| 0| KASSERT(s->s_size > 1, ------------------ | | 46| 0|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 0|#define assert(e) \ | | | | 66| 0|do { \ | | | | 67| 0| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 0] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 0|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 195| 0| ("attempt to create a too small vsb")); 196| 0| } 197| | 198| 13.1k| if (s->s_buf != NULL) ------------------ | Branch (198:6): [True: 0, False: 13.1k] ------------------ 199| 0| return (s); 200| | 201| 13.1k| if ((flags & VSB_AUTOEXTEND) != 0) ------------------ | | 47| 13.1k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ ------------------ | Branch (201:6): [True: 13.1k, False: 0] ------------------ 202| 13.1k| s->s_size = VSB_extendsize(s->s_size); 203| | 204| 13.1k| s->s_buf = SBMALLOC(s->s_size); ------------------ | | 47| 13.1k|#define SBMALLOC(size) malloc(size) ------------------ 205| 13.1k| if (s->s_buf == NULL) ------------------ | Branch (205:6): [True: 0, False: 13.1k] ------------------ 206| 0| return (NULL); 207| 13.1k| VSB_SETFLAG(s, VSB_DYNAMIC); ------------------ | | 64| 13.1k|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 13.1k] | | ------------------ ------------------ 208| 13.1k| return (s); 209| 13.1k|} vsb.c:VSB_extendsize: 122| 26.5k|{ 123| 26.5k| ssize_t newsize; 124| | 125| 26.5k| if (size < (int)VSB_MAXEXTENDSIZE) { ------------------ | | 73| 26.5k|#define VSB_MAXEXTENDSIZE 4096 ------------------ | Branch (125:6): [True: 21.8k, False: 4.69k] ------------------ 126| 21.8k| newsize = VSB_MINEXTENDSIZE; ------------------ | | 67| 21.8k|#define VSB_MINEXTENDSIZE 16 /* Should be power of 2. */ ------------------ 127| 46.8k| while (newsize < size) ------------------ | Branch (127:10): [True: 25.0k, False: 21.8k] ------------------ 128| 25.0k| newsize *= 2; 129| 21.8k| } else { 130| 4.69k| newsize = rndup2(size, VSB_MAXEXTENDINCR); ------------------ | | 50| 4.69k|#define rndup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */ ------------------ 131| 4.69k| } 132| 26.5k| KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size)); ------------------ | | 46| 26.5k|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 26.5k|#define assert(e) \ | | | | 66| 26.5k|do { \ | | | | 67| 26.5k| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 26.5k] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 26.5k|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 26.5k] | | | | ------------------ | | ------------------ ------------------ 133| 26.5k| return (newsize); 134| 26.5k|} vsb.c:_assert_VSB_integrity: 83| 20.0M|{ 84| | 85| 20.0M| (void)fun; 86| 20.0M| (void)s; 87| 20.0M| KASSERT(s != NULL, ------------------ | | 46| 20.0M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 20.0M|#define assert(e) \ | | | | 66| 20.0M|do { \ | | | | 67| 20.0M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 20.0M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 20.0M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 20.0M] | | | | ------------------ | | ------------------ ------------------ 88| 20.0M| ("%s called with a NULL vsb pointer", fun)); 89| 20.0M| KASSERT(s->magic == VSB_MAGIC, ------------------ | | 46| 20.0M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 20.0M|#define assert(e) \ | | | | 66| 20.0M|do { \ | | | | 67| 20.0M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 20.0M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 20.0M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 20.0M] | | | | ------------------ | | ------------------ ------------------ 90| 20.0M| ("%s called with a bogus vsb pointer", fun)); 91| 20.0M| KASSERT(s->s_buf != NULL, ------------------ | | 46| 20.0M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 20.0M|#define assert(e) \ | | | | 66| 20.0M|do { \ | | | | 67| 20.0M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 20.0M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 20.0M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 20.0M] | | | | ------------------ | | ------------------ ------------------ 92| 20.0M| ("%s called with uninitialized or corrupt vsb", fun)); 93| 20.0M| KASSERT(s->s_len < s->s_size, ------------------ | | 46| 20.0M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 20.0M|#define assert(e) \ | | | | 66| 20.0M|do { \ | | | | 67| 20.0M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 20.0M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 20.0M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 20.0M] | | | | ------------------ | | ------------------ ------------------ 94| 20.0M| ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size)); 95| 20.0M|} vsb.c:_assert_VSB_state: 99| 20.0M|{ 100| | 101| 20.0M| (void)fun; 102| 20.0M| (void)s; 103| 20.0M| (void)state; 104| 20.0M| KASSERT((s->s_flags & VSB_FINISHED) == state, ------------------ | | 46| 20.0M|#define KASSERT(e, m) assert(e) | | ------------------ | | | | 65| 20.0M|#define assert(e) \ | | | | 66| 20.0M|do { \ | | | | 67| 20.0M| if (!(e)) { \ | | | | ------------------ | | | | | Branch (67:6): [True: 0, False: 20.0M] | | | | ------------------ | | | | 68| 0| VAS_Fail(__func__, __FILE__, __LINE__, \ | | | | 69| 0| #e, VAS_ASSERT); \ | | | | 70| 0| } \ | | | | 71| 20.0M|} while (0) | | | | ------------------ | | | | | Branch (71:10): [Folded, False: 20.0M] | | | | ------------------ | | ------------------ ------------------ 105| 20.0M| ("%s called with %sfinished or corrupt vsb", fun, 106| 20.0M| (state ? "un" : ""))); 107| 20.0M|} vsb.c:_vsb_indent: 165| 20.0M|{ 166| 20.0M| if (s->s_indent == 0 || s->s_error != 0 || ------------------ | Branch (166:6): [True: 20.0M, False: 0] | Branch (166:26): [True: 0, False: 0] ------------------ 167| 0| (s->s_len > 0 && s->s_buf[s->s_len - 1] != '\n')) ------------------ | Branch (167:7): [True: 0, False: 0] | Branch (167:23): [True: 0, False: 0] ------------------ 168| 20.0M| return; 169| 0| if (VSB_FREESPACE(s) <= s->s_indent && ------------------ | | 58| 0|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (169:6): [True: 0, False: 0] ------------------ 170| 0| VSB_extend(s, s->s_indent) < 0) { ------------------ | Branch (170:6): [True: 0, False: 0] ------------------ 171| 0| s->s_error = ENOMEM; 172| 0| return; 173| 0| } 174| 0| memset(s->s_buf + s->s_len, ' ', s->s_indent); 175| 0| s->s_len += s->s_indent; 176| 0|} vsb.c:VSB_extend: 141| 13.3k|{ 142| 13.3k| char *newbuf; 143| 13.3k| ssize_t newsize; 144| | 145| 13.3k| if (!VSB_CANEXTEND(s)) ------------------ | | 59| 13.3k|#define VSB_CANEXTEND(s) ((s)->s_flags & VSB_AUTOEXTEND) | | ------------------ | | | | 47| 13.3k|#define VSB_AUTOEXTEND 0x00000001 /* automatically extend buffer */ | | ------------------ ------------------ | Branch (145:6): [True: 0, False: 13.3k] ------------------ 146| 0| return (-1); 147| 13.3k| newsize = VSB_extendsize(s->s_size + addlen); 148| 13.3k| if (VSB_ISDYNAMIC(s)) ------------------ | | 55| 13.3k|#define VSB_ISDYNAMIC(s) ((s)->s_flags & VSB_DYNAMIC) | | ------------------ | | | | 49| 13.3k|#define VSB_DYNAMIC 0x00010000 /* s_buf must be freed */ | | ------------------ | | | Branch (55:26): [True: 13.3k, False: 0] | | ------------------ ------------------ 149| 13.3k| newbuf = realloc(s->s_buf, newsize); 150| 0| else 151| 0| newbuf = SBMALLOC(newsize); ------------------ | | 47| 0|#define SBMALLOC(size) malloc(size) ------------------ 152| 13.3k| if (newbuf == NULL) ------------------ | Branch (152:6): [True: 0, False: 13.3k] ------------------ 153| 0| return (-1); 154| 13.3k| if (!VSB_ISDYNAMIC(s)) { ------------------ | | 55| 13.3k|#define VSB_ISDYNAMIC(s) ((s)->s_flags & VSB_DYNAMIC) | | ------------------ | | | | 49| 13.3k|#define VSB_DYNAMIC 0x00010000 /* s_buf must be freed */ | | ------------------ ------------------ | Branch (154:6): [True: 0, False: 13.3k] ------------------ 155| 0| vmemcpy(newbuf, s->s_buf, s->s_size); ------------------ | | 375| 0|# define vmemcpy(d, s, n) __builtin_memcpy(d, s, n) ------------------ 156| 0| VSB_SETFLAG(s, VSB_DYNAMIC); ------------------ | | 64| 0|#define VSB_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) | | ------------------ | | | Branch (64:62): [Folded, False: 0] | | ------------------ ------------------ 157| 0| } 158| 13.3k| s->s_buf = newbuf; 159| 13.3k| s->s_size = newsize; 160| 13.3k| return (0); 161| 13.3k|} vsb.c:VSB_put_byte: 264| 15.1M|{ 265| | 266| 15.1M| assert_VSB_integrity(s); ------------------ | | 108| 15.1M|#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s)) ------------------ 267| 15.1M| assert_VSB_state(s, 0); ------------------ | | 109| 15.1M|#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i)) ------------------ 268| | 269| 15.1M| if (s->s_error != 0) ------------------ | Branch (269:6): [True: 0, False: 15.1M] ------------------ 270| 0| return; 271| 15.1M| _vsb_indent(s); 272| 15.1M| if (VSB_FREESPACE(s) <= 0) { ------------------ | | 58| 15.1M|#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L)) ------------------ | Branch (272:6): [True: 10.3k, False: 15.0M] ------------------ 273| 10.3k| if (VSB_extend(s, 1) < 0) ------------------ | Branch (273:7): [True: 0, False: 10.3k] ------------------ 274| 0| s->s_error = ENOMEM; 275| 10.3k| if (s->s_error != 0) ------------------ | Branch (275:7): [True: 0, False: 10.3k] ------------------ 276| 0| return; 277| 10.3k| } 278| 15.1M| s->s_buf[s->s_len++] = (char)c; 279| 15.1M|}