../3rdparty/pcre/pcre_jit_compile.c

executed (the execution status of this line is deduced): cc += 1 + 1;

436

SLJIT_UNUSED_ARG(common);

executed: return cc;

Execution Count:45

437 } -

438 -

439 /* Functions whose might need modification for all new supported opcodes: -

440 next_opcode -

441 get_localspace -

442 set_localptrs -

443 get_framesize -

444 init_frame -

445 get_localsize -

446 copy_locals -

447 compile_hotpath -

448 compile_fallbackpath -

449 */ -

450 -

451 static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc) -

452 { -

453

executed (the execution status of this line is deduced): (void)common;

454 switch(*cc) -

455 { -

456 case OP_SOD: -

457 case OP_SOM: -

458 case OP_SET_SOM: -

459 case OP_NOT_WORD_BOUNDARY: -

460 case OP_WORD_BOUNDARY: -

461 case OP_NOT_DIGIT: -

462 case OP_DIGIT: -

463 case OP_NOT_WHITESPACE: -

464 case OP_WHITESPACE: -

465 case OP_NOT_WORDCHAR: -

466 case OP_WORDCHAR: -

467 case OP_ANY: -

468 case OP_ALLANY: -

469 case OP_ANYNL: -

470 case OP_NOT_HSPACE: -

471 case OP_HSPACE: -

472 case OP_NOT_VSPACE: -

473 case OP_VSPACE: -

474 case OP_EXTUNI: -

475 case OP_EODN: -

476 case OP_EOD: -

477 case OP_CIRC: -

478 case OP_CIRCM: -

479 case OP_DOLL: -

480 case OP_DOLLM: -

481 case OP_TYPESTAR: -

482 case OP_TYPEMINSTAR: -

483 case OP_TYPEPLUS: -

484 case OP_TYPEMINPLUS: -

485 case OP_TYPEQUERY: -

486 case OP_TYPEMINQUERY: -

487 case OP_TYPEPOSSTAR: -

488 case OP_TYPEPOSPLUS: -

489 case OP_TYPEPOSQUERY: -

490 case OP_CRSTAR: -

491 case OP_CRMINSTAR: -

492 case OP_CRPLUS: -

493 case OP_CRMINPLUS: -

494 case OP_CRQUERY: -

495 case OP_CRMINQUERY: -

496 case OP_DEF: -

497 case OP_BRAZERO: -

498 case OP_BRAMINZERO: -

499 case OP_BRAPOSZERO: -

500 case OP_FAIL: -

501 case OP_ACCEPT: -

502 case OP_ASSERT_ACCEPT: -

503 case OP_SKIPZERO: -

504

if (common->utf) return NULL;

executed: return cc + 1;

Execution Count:29

505 -

506 case OP_ANYBYTE: -

507 #ifdef SUPPORT_UTF -

508

never executed: return ((void *)0);

never evaluated: common->utf

509 #endif -

510

never executed: return cc + 1;

511 -

512 case OP_CHAR: -

513 case OP_CHARI: -

514 case OP_NOT: -

515 case OP_NOTI: -

516 case OP_STAR: -

517 case OP_MINSTAR: -

518 case OP_PLUS: -

519 case OP_MINPLUS: -

520 case OP_QUERY: -

521 case OP_MINQUERY: -

522 case OP_POSSTAR: -

523 case OP_POSPLUS: -

524 case OP_POSQUERY: -

525 case OP_STARI: -

526 case OP_MINSTARI: -

527 case OP_PLUSI: -

528 case OP_MINPLUSI: -

529 case OP_QUERYI: -

530 case OP_MINQUERYI: -

531 case OP_POSSTARI: -

532 case OP_POSPLUSI: -

533 case OP_POSQUERYI: -

534 case OP_NOTSTAR: -

535 case OP_NOTMINSTAR: -

536 case OP_NOTPLUS: -

537 case OP_NOTMINPLUS: -

538 case OP_NOTQUERY: -

539 case OP_NOTMINQUERY: -

540 case OP_NOTPOSSTAR: -

541 case OP_NOTPOSPLUS: -

542 case OP_NOTPOSQUERY: -

543 case OP_NOTSTARI: -

544 case OP_NOTMINSTARI: -

545 case OP_NOTPLUSI: -

546 case OP_NOTMINPLUSI: -

547 case OP_NOTQUERYI: -

548 case OP_NOTMINQUERYI: -

549 case OP_NOTPOSSTARI: -

550 case OP_NOTPOSPLUSI: -

551 case OP_NOTPOSQUERYI: -

552

if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

executed (the execution status of this line is deduced): cc += 2;

553 #ifdef SUPPORT_UTF -

554

never executed: cc += 1;

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:18	no Evaluation Count:0

partially evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:18

0-18

555 #endif -

556

if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

executed: return cc;

Execution Count:18

557 -

558 case OP_UPTO: -

559 case OP_MINUPTO: -

560 case OP_EXACT: -

561 case OP_POSUPTO: -

562 case OP_UPTOI: -

563 case OP_MINUPTOI: -

564 case OP_EXACTI: -

565 case OP_POSUPTOI: -

566 case OP_NOTUPTO: -

567 case OP_NOTMINUPTO: -

568 case OP_NOTEXACT: -

569 case OP_NOTPOSUPTO: -

570 case OP_NOTUPTOI: -

571 case OP_NOTMINUPTOI: -

572 case OP_NOTEXACTI: -

573 case OP_NOTPOSUPTOI: -

574

cc += 2 + IMM2_SIZE;

never executed (the execution status of this line is deduced): cc += 2 + 1;

575 #ifdef SUPPORT_UTF -

576

never executed: cc += 1;

never evaluated: common->utf

never evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

577 #endif -

578

never executed: return cc;

579 -

580 case OP_NOTPROP: -

581 case OP_PROP: -

582

return cc + 1 + 2;

never executed: return cc + 1 + 2;

583 -

584 case OP_TYPEUPTO: -

585 case OP_TYPEMINUPTO: -

586 case OP_TYPEEXACT: -

587 case OP_TYPEPOSUPTO: -

588 case OP_REF: -

589 case OP_REFI: -

590 case OP_CREF: -

591 case OP_NCREF: -

592 case OP_RREF: -

593 case OP_NRREF: -

594 case OP_CLOSE: -

595

cc += 1 + IMM2_SIZE;

never executed (the execution status of this line is deduced): cc += 1 + 1;

596

return cc + 1 + 2 * IMM2_SIZE;

never executed: return cc;

597 -

598 case OP_CRRANGE: -

599 case OP_CRMINRANGE: -

600

never executed: return cc + 1 + 2 * 1;

601 -

602 case OP_CLASS: -

603 case OP_NCLASS: -

604

return cc + 1 + 32 / sizeof(pcre_uchar);

never executed: return cc + 1 + 32 / sizeof(pcre_uchar);

605 -

606 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

607 case OP_XCLASS: -

608

return cc + GET(cc, 1);

executed: return cc + (cc[1]);

Execution Count:2

609 #endif -

610 -

611 case OP_RECURSE: -

612 case OP_ASSERT: -

613 case OP_ASSERT_NOT: -

614 case OP_ASSERTBACK: -

615 case OP_ASSERTBACK_NOT: -

616 case OP_REVERSE: -

617 case OP_ONCE: -

618 case OP_ONCE_NC: -

619 case OP_BRA: -

620 case OP_BRAPOS: -

621 case OP_COND: -

622 case OP_SBRA: -

623 case OP_SBRAPOS: -

624 case OP_SCOND: -

625 case OP_ALT: -

626 case OP_KET: -

627 case OP_KETRMAX: -

628 case OP_KETRMIN: -

629 case OP_KETRPOS: -

630

return cc + 1 + LINK_SIZE + IMM2_SIZE;

executed: return cc + 1 + 1;

Execution Count:62

631 -

632 case OP_CBRA: -

633 case OP_CBRAPOS: -

634 case OP_SCBRA: -

635 case OP_SCBRAPOS: -

636

never executed: return cc + 1 + 1 + 1;

637 -

638 default: -

639

never executed: return ((void *)0);

640 } -

641

never executed: }

642 -

643 static int get_localspace(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend) -

644 { -

645

int localspace = 0;

executed (the execution status of this line is deduced): int localspace = 0;

646

executed (the execution status of this line is deduced): pcre_uchar *alternative;

647 /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */ -

648

localspace += sizeof(sljit_w);

evaluated: cc < ccend

TRUE	FALSE
yes Evaluation Count:53	yes Evaluation Count:15

15-53

649 { -

650 switch(*cc) -

651 { -

652 case OP_ASSERT: -

653 case OP_ASSERT_NOT: -

654 case OP_ASSERTBACK: -

655 case OP_ASSERTBACK_NOT: -

656 case OP_ONCE: -

657 case OP_ONCE_NC: -

658 case OP_BRAPOS: -

659 case OP_SBRA: -

660 case OP_SBRAPOS: -

661 case OP_SCOND: -

662

never executed (the execution status of this line is deduced): localspace += sizeof(sljit_w);

663

never executed (the execution status of this line is deduced): cc += 1 + 1;

664

localspace += sizeof(sljit_w);

never executed: break;

665 -

666 case OP_CBRAPOS: -

667 case OP_SCBRAPOS: -

668

never executed (the execution status of this line is deduced): localspace += sizeof(sljit_w);

669

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

670

never executed: break;

671 -

672 case OP_COND: -

673 /* Might be a hidden SCOND. */ -

674

if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)

never executed (the execution status of this line is deduced): alternative = cc + (cc[1]);

675

never evaluated: *alternative == OP_KETRMAX

never evaluated: *alternative == OP_KETRMIN

676

localspace += sizeof(sljit_w);

never executed: localspace += sizeof(sljit_w);

677

never executed (the execution status of this line is deduced): cc += 1 + 1;

678

never executed: break;

679 -

680 default: -

681

executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

682

if (cc == NULL)

partially evaluated: cc == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:53

0-53

683

return -1;

never executed: return -1;

684

executed: break;

Execution Count:53

685 } -

686

pcre_uchar *cc = common->start;

executed: }

Execution Count:53

687

return localspace;

executed: return localspace;

Execution Count:15

688 } -

689 -

690 static void set_localptrs(compiler_common *common, int localptr, pcre_uchar *ccend) -

691 { -

692

executed (the execution status of this line is deduced): pcre_uchar *cc = common->start;

693

executed (the execution status of this line is deduced): pcre_uchar *alternative;

694

common->localptrs[cc - common->start] = localptr;

evaluated: cc < ccend

TRUE	FALSE
yes Evaluation Count:53	yes Evaluation Count:15

15-53

695 { -

696 switch(*cc) -

697 { -

698 case OP_ASSERT: -

699 case OP_ASSERT_NOT: -

700 case OP_ASSERTBACK: -

701 case OP_ASSERTBACK_NOT: -

702 case OP_ONCE: -

703 case OP_ONCE_NC: -

704 case OP_BRAPOS: -

705 case OP_SBRA: -

706 case OP_SBRAPOS: -

707 case OP_SCOND: -

708

never executed (the execution status of this line is deduced): common->localptrs[cc - common->start] = localptr;

709

localptr += sizeof(sljit_w);

never executed (the execution status of this line is deduced): localptr += sizeof(sljit_w);

710

never executed (the execution status of this line is deduced): cc += 1 + 1;

711

common->localptrs[cc - common->start] = localptr;

never executed: break;

712 -

713 case OP_CBRAPOS: -

714 case OP_SCBRAPOS: -

715

never executed (the execution status of this line is deduced): common->localptrs[cc - common->start] = localptr;

716

localptr += sizeof(sljit_w);

never executed (the execution status of this line is deduced): localptr += sizeof(sljit_w);

717

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

718

never executed: break;

719 -

720 case OP_COND: -

721 /* Might be a hidden SCOND. */ -

722

if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)

never executed (the execution status of this line is deduced): alternative = cc + (cc[1]);

723

never evaluated: *alternative == OP_KETRMAX

never evaluated: *alternative == OP_KETRMIN

724 { -

725

common->localptrs[cc - common->start] = localptr;

never executed (the execution status of this line is deduced): common->localptrs[cc - common->start] = localptr;

726

localptr += sizeof(sljit_w);

never executed (the execution status of this line is deduced): localptr += sizeof(sljit_w);

never executed: }

never executed (the execution status of this line is deduced): cc += 1 + 1;

729

never executed: break;

730 -

731 default: -

732

executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

733

executed: }

Execution Count:53

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:53

0-53

734

executed: break;

Execution Count:53

735 } -

736

executed: }

Execution Count:53

737

pcre_uchar *ccend = bracketend(cc);

executed: }

Execution Count:15

738 -

739 /* Returns with -1 if no need for frame. */ -

740 static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive) -

741 { -

742

never executed (the execution status of this line is deduced): pcre_uchar *ccend = bracketend(cc);

743

int length = 0;

never executed (the execution status of this line is deduced): int length = 0;

744

BOOL possessive = FALSE;

never executed (the execution status of this line is deduced): BOOL possessive = 0;

745

BOOL setsom_found = FALSE;

never executed (the execution status of this line is deduced): BOOL setsom_found = 0;

746 -

747

if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))

never evaluated: !recursive

never evaluated: *cc == OP_CBRAPOS

never evaluated: *cc == OP_SCBRAPOS

748 { -

749

length = 3;

never executed (the execution status of this line is deduced): length = 3;

750

possessive = TRUE;

never executed (the execution status of this line is deduced): possessive = 1;

751

never executed: }

752 -

753

never executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

754

never executed: }

never evaluated: 0

755

never evaluated: cc < ccend

756 switch(*cc) -

757 { -

758 case OP_SET_SOM: -

759 case OP_RECURSE: -

760

if (!setsom_found)

never evaluated: !setsom_found

761 { -

762

length += 2;

never executed (the execution status of this line is deduced): length += 2;

763

setsom_found = TRUE;

never executed (the execution status of this line is deduced): setsom_found = 1;

764

cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;

never executed: }

765

never evaluated: (*cc == OP_SET_SOM)

766

never executed: break;

767 -

768 case OP_CBRA: -

769 case OP_CBRAPOS: -

770 case OP_SCBRA: -

771 case OP_SCBRAPOS: -

772

length += 3;

never executed (the execution status of this line is deduced): length += 3;

773

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

774

never executed: break;

775 -

776 default: -

777

never executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

778

never executed: }

never evaluated: 0

779

never executed: break;

780

if (SLJIT_UNLIKELY(possessive) && length == 3)

never executed: }

781 -

782 /* Possessive quantifiers can use a special case. */ -

783

never evaluated: __builtin_expect((possessive), 0)

never evaluated: length == 3

784

return -1;

never executed: return -1;

785 -

786

if (length > 0)

never evaluated: length > 0

787

return length + 1;

never executed: return length + 1;

788

return -1;

never executed: return -1;

789 } -

790 -

791 static void init_frame(compiler_common *common, pcre_uchar *cc, int stackpos, int stacktop, BOOL recursive) -

792 { -

793

pcre_uchar *ccend = bracketend(cc);

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

794

never executed (the execution status of this line is deduced): pcre_uchar *ccend = bracketend(cc);

795

BOOL setsom_found = FALSE;

never executed (the execution status of this line is deduced): BOOL setsom_found = 0;

796

int offset;

never executed (the execution status of this line is deduced): int offset;

797 -

798 /* >= 1 + shortest item size (2) */ -

799

SLJIT_UNUSED_ARG(stacktop);

never executed (the execution status of this line is deduced): (void)stacktop;

800

SLJIT_ASSERT(stackpos >= stacktop + 2);

never executed: }

never evaluated: 0

801 -

802

stackpos = STACK(stackpos);

never executed (the execution status of this line is deduced): stackpos = ((-(stackpos) - 1) * (int)sizeof(sljit_w));

803

if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))

never evaluated: recursive

never evaluated: *cc != OP_CBRAPOS

never evaluated: *cc != OP_SCBRAPOS

804

never executed: cc = next_opcode(common, cc);

805

never executed: }

never evaluated: 0

806

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));

never evaluated: cc < ccend

807 switch(*cc) -

808 { -

809 case OP_SET_SOM: -

810 case OP_RECURSE: -

811

if (!setsom_found)

never evaluated: !setsom_found

812 { -

813

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))));

814

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackpos), (0x200), (frame_setstrbegin));

815

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);

never executed (the execution status of this line is deduced): stackpos += (int)sizeof(sljit_w);

816

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackpos), (1), (0));

817

never executed (the execution status of this line is deduced): stackpos += (int)sizeof(sljit_w);

818

setsom_found = TRUE;

never executed (the execution status of this line is deduced): setsom_found = 1;

819

cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;

never executed: }

820

never evaluated: (*cc == OP_SET_SOM)

821

offset = (GET2(cc, 1 + LINK_SIZE)) << 1;

never executed: break;

822 -

823 case OP_CBRA: -

824 case OP_CBRAPOS: -

825 case OP_SCBRA: -

826 case OP_SCBRAPOS: -

827

never executed (the execution status of this line is deduced): offset = (cc[1 + 1]) << 1;

828

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackpos), (0x200), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))));

829

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));

never executed (the execution status of this line is deduced): stackpos += (int)sizeof(sljit_w);

830

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))));

831

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))));

832

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackpos), (1), (0));

833

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);

never executed (the execution status of this line is deduced): stackpos += (int)sizeof(sljit_w);

834

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackpos), (3), (0));

835

never executed (the execution status of this line is deduced): stackpos += (int)sizeof(sljit_w);

836 -

837

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

838

never executed: break;

839 -

840 default: -

841

never executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

842

never executed: }

never evaluated: 0

843

never executed: break;

844

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);

never executed: }

845 -

846

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackpos), (0x200), (frame_end));

847

SLJIT_ASSERT(stackpos == STACK(stacktop));

never executed: }

never evaluated: 0

848

never executed: }

849 -

850 static SLJIT_INLINE int get_localsize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend) -

851 { -

852

int localsize = 2;

never executed (the execution status of this line is deduced): int localsize = 2;

853

never executed (the execution status of this line is deduced): pcre_uchar *alternative;

854 /* Calculate the sum of the local variables. */ -

855

never evaluated: cc < ccend

856 { -

857 switch(*cc) -

858 { -

859 case OP_ASSERT: -

860 case OP_ASSERT_NOT: -

861 case OP_ASSERTBACK: -

862 case OP_ASSERTBACK_NOT: -

863 case OP_ONCE: -

864 case OP_ONCE_NC: -

865 case OP_BRAPOS: -

866 case OP_SBRA: -

867 case OP_SBRAPOS: -

868 case OP_SCOND: -

869

localsize++;

never executed (the execution status of this line is deduced): localsize++;

870

never executed (the execution status of this line is deduced): cc += 1 + 1;

871

never executed: break;

872 -

873 case OP_CBRA: -

874 case OP_SCBRA: -

875

localsize++;

never executed (the execution status of this line is deduced): localsize++;

876

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

877

never executed: break;

878 -

879 case OP_CBRAPOS: -

880 case OP_SCBRAPOS: -

881

localsize += 2;

never executed (the execution status of this line is deduced): localsize += 2;

882

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

883

never executed: break;

884 -

885 case OP_COND: -

886 /* Might be a hidden SCOND. */ -

887

if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)

never executed (the execution status of this line is deduced): alternative = cc + (cc[1]);

888

never evaluated: *alternative == OP_KETRMAX

never evaluated: *alternative == OP_KETRMIN

889

localsize++;

never executed: localsize++;

890

never executed (the execution status of this line is deduced): cc += 1 + 1;

891

never executed: break;

892 -

893 default: -

894

never executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

895

never executed: }

never evaluated: 0

896

never executed: break;

897 } -

898

SLJIT_ASSERT(cc == ccend);

never executed: }

899

never executed: }

never evaluated: 0

900

return localsize;

never executed: return localsize;

901 } -

902 -

903 static void copy_locals(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, -

904 BOOL save, int stackptr, int stacktop) -

905 { -

906

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

907

int srcw[2];

never executed (the execution status of this line is deduced): int srcw[2];

908

int count;

never executed (the execution status of this line is deduced): int count;

909

BOOL tmp1next = TRUE;

never executed (the execution status of this line is deduced): BOOL tmp1next = 1;

910

BOOL tmp1empty = TRUE;

never executed (the execution status of this line is deduced): BOOL tmp1empty = 1;

911

BOOL tmp2empty = TRUE;

never executed (the execution status of this line is deduced): BOOL tmp2empty = 1;

912

status = save ? start : loop;

never executed (the execution status of this line is deduced): pcre_uchar *alternative;

913

enum {

never executed (the execution status of this line is deduced): enum {

914

start,

never executed (the execution status of this line is deduced): start,

915

loop,

never executed (the execution status of this line is deduced): loop,

916

end

never executed (the execution status of this line is deduced): end

917

} status;

never executed (the execution status of this line is deduced): } status;

918 -

919

never evaluated: save

920

stackptr = STACK(stackptr - 2);

never executed (the execution status of this line is deduced): stackptr = ((-(stackptr - 2) - 1) * (int)sizeof(sljit_w));

921

stacktop = STACK(stacktop - 1);

never executed (the execution status of this line is deduced): stacktop = ((-(stacktop - 1) - 1) * (int)sizeof(sljit_w));

922 -

923

if (!save)

never evaluated: !save

924 { -

925

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

926

if (stackptr < stacktop)

never evaluated: stackptr < stacktop

927 { -

928

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (stackptr));

929

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

930

tmp1empty = FALSE;

never executed (the execution status of this line is deduced): tmp1empty = 0;

931

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);

never executed: }

932

if (stackptr < stacktop)

never evaluated: stackptr < stacktop

933 { -

934

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (stackptr));

935

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

936

tmp2empty = FALSE;

never executed (the execution status of this line is deduced): tmp2empty = 0;

937

never executed: }

938 /* The tmp1next must be TRUE in either way. */ -

939

never executed: }

940 -

941

while (status != end)

never evaluated: status != end

942 { -

943

count = 0;

never executed (the execution status of this line is deduced): count = 0;

944 switch(status) -

945 { -

946 case start: -

947

SLJIT_ASSERT(save);

never executed: }

never evaluated: 0

948

srcw[0] = RECURSIVE_HEAD;

never executed (the execution status of this line is deduced): count = 1;

949

never executed (the execution status of this line is deduced): srcw[0] = (4 * sizeof(sljit_w));

950

status = loop;

never executed (the execution status of this line is deduced): status = loop;

951

never executed: break;

952 -

953 case loop: -

954

if (cc >= ccend)

never evaluated: cc >= ccend

955 { -

956

status = end;

never executed (the execution status of this line is deduced): status = end;

957

never executed: break;

958 } -

959 -

960 switch(*cc) -

961 { -

962 case OP_ASSERT: -

963 case OP_ASSERT_NOT: -

964 case OP_ASSERTBACK: -

965 case OP_ASSERTBACK_NOT: -

966 case OP_ONCE: -

967 case OP_ONCE_NC: -

968 case OP_BRAPOS: -

969 case OP_SBRA: -

970 case OP_SBRAPOS: -

971 case OP_SCOND: -

972

SLJIT_ASSERT(srcw[0] != 0);

never executed (the execution status of this line is deduced): count = 1;

973

srcw[0] = PRIV_DATA(cc);

never executed (the execution status of this line is deduced): srcw[0] = (common->localptrs[(cc) - common->start]);

974

never executed: }

never evaluated: 0

975

never executed (the execution status of this line is deduced): cc += 1 + 1;

976

never executed: break;

977 -

978 case OP_CBRA: -

979 case OP_SCBRA: -

980

srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));

never executed (the execution status of this line is deduced): count = 1;

981

never executed (the execution status of this line is deduced): srcw[0] = (common->cbraptr + (cc[1 + 1]) * sizeof(sljit_w));

982

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

983

srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));

never executed: break;

984 -

985 case OP_CBRAPOS: -

986 case OP_SCBRAPOS: -

987

count = 2;

never executed (the execution status of this line is deduced): count = 2;

988

never executed (the execution status of this line is deduced): srcw[1] = (common->cbraptr + (cc[1 + 1]) * sizeof(sljit_w));

989

srcw[0] = PRIV_DATA(cc);

never executed (the execution status of this line is deduced): srcw[0] = (common->localptrs[(cc) - common->start]);

990

SLJIT_ASSERT(srcw[0] != 0);

never executed: }

never evaluated: 0

991

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

992

never executed: break;

993 -

994 case OP_COND: -

995 /* Might be a hidden SCOND. */ -

996

if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)

never executed (the execution status of this line is deduced): alternative = cc + (cc[1]);

997

never evaluated: *alternative == OP_KETRMAX

never evaluated: *alternative == OP_KETRMIN

998 { -

999

SLJIT_ASSERT(srcw[0] != 0);

never executed (the execution status of this line is deduced): count = 1;

1000

srcw[0] = PRIV_DATA(cc);

never executed (the execution status of this line is deduced): srcw[0] = (common->localptrs[(cc) - common->start]);

1001

never executed: }

never evaluated: 0

never executed: }

never executed (the execution status of this line is deduced): cc += 1 + 1;

1004

never executed: break;

1005 -

1006 default: -

1007

never executed (the execution status of this line is deduced): cc = next_opcode(common, cc);

1008

never executed: }

never evaluated: 0

1009

never executed: break;

1010 } -

1011

never executed: break;

1012 -

1013 case end: -

1014

never executed: }

never evaluated: 0

1015

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);

never executed: break;

1016 } -

1017 -

1018

while (count > 0)

never evaluated: count > 0

1019 { -

1020

count--;

never executed (the execution status of this line is deduced): count--;

1021

if (save)

never evaluated: save

1022 { -

1023

if (tmp1next)

never evaluated: tmp1next

1024 { -

1025

if (!tmp1empty)

never evaluated: !tmp1empty

1026 { -

1027

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackptr), (1), (0));

1028

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

1029

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);

never executed: }

1030

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (srcw[count]));

1031

tmp1empty = FALSE;

never executed (the execution status of this line is deduced): tmp1empty = 0;

1032

tmp1next = FALSE;

never executed (the execution status of this line is deduced): tmp1next = 0;

1033

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);

never executed: }

1034 else -

1035 { -

1036

if (!tmp2empty)

never evaluated: !tmp2empty

1037 { -

1038

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackptr), (3), (0));

1039

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

1040

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);

never executed: }

1041

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (srcw[count]));

1042

tmp2empty = FALSE;

never executed (the execution status of this line is deduced): tmp2empty = 0;

1043

tmp1next = TRUE;

never executed (the execution status of this line is deduced): tmp1next = 1;

1044

SLJIT_ASSERT(!tmp1empty);

never executed: }

1045 } -

1046 else -

1047 { -

1048

if (tmp1next)

never evaluated: tmp1next

1049 { -

1050

never executed: }

never evaluated: 0

1051

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (srcw[count]), (1), (0));

1052

tmp1empty = stackptr >= stacktop;

never executed (the execution status of this line is deduced): tmp1empty = stackptr >= stacktop;

1053

if (!tmp1empty)

never evaluated: !tmp1empty

1054 { -

1055

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (stackptr));

1056

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

never executed: }

never executed (the execution status of this line is deduced): tmp1next = 0;

1059

SLJIT_ASSERT(!tmp2empty);

never executed: }

1060 else -

1061 { -

1062

never executed: }

never evaluated: 0

1063

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (srcw[count]), (3), (0));

1064

tmp2empty = stackptr >= stacktop;

never executed (the execution status of this line is deduced): tmp2empty = stackptr >= stacktop;

1065

if (!tmp2empty)

never evaluated: !tmp2empty

1066 { -

1067

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (stackptr));

1068

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

never executed: }

never executed (the execution status of this line is deduced): tmp1next = 1;

1071

never executed: }

1072 } -

1073 } -

1074

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);

never executed: }

1075 -

1076

if (save)

never evaluated: save

1077 { -

1078

if (tmp1next)

never evaluated: tmp1next

1079 { -

1080

if (!tmp1empty)

never evaluated: !tmp1empty

1081 { -

1082

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackptr), (1), (0));

1083

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

never executed: }

never evaluated: !tmp2empty

1086 { -

1087

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackptr), (3), (0));

1088

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

never executed: }

never executed: }

1091 else -

1092 { -

1093

if (!tmp2empty)

never evaluated: !tmp2empty

1094 { -

1095

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackptr), (3), (0));

1096

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

never executed: }

never evaluated: !tmp1empty

1099 { -

1100

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (stackptr), (1), (0));

1101

SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));

never executed (the execution status of this line is deduced): stackptr += sizeof(sljit_w);

never executed: }

never executed: }

1104 } -

1105

never executed: }

never evaluated: 0

1106

return (value & (value - 1)) == 0;

never executed: }

1107 -

1108 static SLJIT_INLINE BOOL ispowerof2(unsigned int value) -

1109 { -

1110

never executed: return (value & (value - 1)) == 0;

1111 } -

1112 -

1113 static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label) -

1114 { -

1115

while (list)

evaluated: list

TRUE	FALSE
yes Evaluation Count:65	yes Evaluation Count:57

57-65

1116 { -

1117 /* sljit_set_label is clever enough to do nothing -

1118 if either the jump or the label is NULL */ -

1119

sljit_set_label(list->jump, label);

executed (the execution status of this line is deduced): sljit_set_label(list->jump, label);

1120

list = list->next;

executed (the execution status of this line is deduced): list = list->next;

1121

executed: }

Execution Count:65

1122

jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));

executed: }

Execution Count:57

1123 -

1124 static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump* jump) -

1125 { -

1126

executed (the execution status of this line is deduced): jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));

1127

if (list_item)

partially evaluated: list_item

TRUE	FALSE
yes Evaluation Count:65	no Evaluation Count:0

0-65

1128 { -

1129

list_item->next = *list;

executed (the execution status of this line is deduced): list_item->next = *list;

1130

list_item->jump = jump;

executed (the execution status of this line is deduced): list_item->jump = jump;

1131

*list = list_item;

executed (the execution status of this line is deduced): *list = list_item;

1132

executed: }

Execution Count:65

1133

executed: }

Execution Count:65

1134 -

1135 static void add_stub(compiler_common *common, enum stub_types type, int data, struct sljit_jump *start) -

1136 { -

1137

stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1138

executed (the execution status of this line is deduced): stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));

1139 -

1140

if (list_item)

partially evaluated: list_item

TRUE	FALSE
yes Evaluation Count:11	no Evaluation Count:0

0-11

1141 { -

1142

list_item->type = type;

executed (the execution status of this line is deduced): list_item->type = type;

1143

list_item->data = data;

executed (the execution status of this line is deduced): list_item->data = data;

1144

list_item->start = start;

executed (the execution status of this line is deduced): list_item->start = start;

1145

list_item->leave = LABEL();

executed (the execution status of this line is deduced): list_item->leave = sljit_emit_label(compiler);

1146

list_item->next = common->stubs;

executed (the execution status of this line is deduced): list_item->next = common->stubs;

1147

common->stubs = list_item;

executed (the execution status of this line is deduced): common->stubs = list_item;

1148

executed: }

Execution Count:11

1149

executed: }

Execution Count:11

1150 -

1151 static void flush_stubs(compiler_common *common) -

1152 { -

1153

stub_list* list_item = common->stubs;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1154

executed (the execution status of this line is deduced): stub_list* list_item = common->stubs;

1155 -

1156

while (list_item)

evaluated: list_item

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:15

11-15

1157 { -

1158

JUMPHERE(list_item->start);

executed (the execution status of this line is deduced): sljit_set_label((list_item->start), sljit_emit_label(compiler));

1159 switch(list_item->type) -

1160 { -

1161 case stack_alloc: -

1162

add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));

executed (the execution status of this line is deduced): add_jump(compiler, &common->stackalloc, sljit_emit_jump(compiler, (23)));

1163

JUMPTO(SLJIT_JUMP, list_item->leave);

executed: break;

Execution Count:11

1164 } -

1165

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (list_item->leave));

1166

list_item = list_item->next;

executed (the execution status of this line is deduced): list_item = list_item->next;

1167

executed: }

Execution Count:11

1168

common->stubs = NULL;

executed (the execution status of this line is deduced): common->stubs = ((void *)0);

1169

executed: }

Execution Count:15

1170 -

1171 static SLJIT_INLINE void decrease_call_count(compiler_common *common) -

1172 { -

1173

OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1174 -

1175

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (10), (0), (10), (0), (0x200), (1));

1176

add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));

executed (the execution status of this line is deduced): add_jump(compiler, &common->calllimit, sljit_emit_jump(compiler, (0)));

1177

executed: }

Execution Count:8

1178 -

1179 static SLJIT_INLINE void allocate_stack(compiler_common *common, int size) -

1180 { -

1181 /* May destroy all locals and registers except TMP2. */ -

1182

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_w));

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1183 -

1184

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (size * sizeof(sljit_w)));

1185 #ifdef DESTROY_REGISTERS -

1186 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345); -

1187 OP1(SLJIT_MOV, TMP3, 0, TMP1, 0); -

1188 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0); -

1189 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0); -

1190 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0); -

1191 #endif -

1192

add_stub(common, stack_alloc, 0, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));

executed (the execution status of this line is deduced): add_stub(common, stack_alloc, 0, sljit_emit_cmp(compiler, (4), (2), (0), (8), (0)));

1193

executed: }

Execution Count:11

1194 -

1195 static SLJIT_INLINE void free_stack(compiler_common *common, int size) -

1196 { -

1197

OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_w));

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1198

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (2), (0), (2), (0), (0x200), (size * sizeof(sljit_w)));

1199

executed: }

Execution Count:10

1200 -

1201 static SLJIT_INLINE void reset_ovector(compiler_common *common, int length) -

1202 { -

1203

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1204

OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): struct sljit_label *loop;

1205

int i;

executed (the execution status of this line is deduced): int i;

1206 /* At this point we can freely use all temporary registers. */ -

1207 /* TMP1 returns with begin - 1. */ -

1208

executed (the execution status of this line is deduced):

sljit_emit_op2(compiler, (25), (1), (0), ((0x100 | (6))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)), (0x200), (((1) << 1)));

1209

if (length < 8)

partially evaluated: length < 8

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1210 { -

1211

for (i = 0; i < length; i++)

evaluated: i < length

TRUE	FALSE
yes Evaluation Count:30	yes Evaluation Count:15

15-30

1212

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_TEMPORARY_REG1, 0);

executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (i) * sizeof(sljit_w))), (1), (0));

Execution Count:30

1213

OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START - sizeof(sljit_w));

executed: }

Execution Count:15

1214 else -

1215 { -

1216

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (11), (0), (0x200), ((8 * sizeof(sljit_w)) - sizeof(sljit_w)));

1217

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, length);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (length));

1218

OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(sljit_w), SLJIT_TEMPORARY_REG1, 0);

never executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

1219

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (13), ((0x100 | (2))), (sizeof(sljit_w)), (1), (0));

1220

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (3), (0), (3), (0), (0x200), (1));

1221

JUMPTO(SLJIT_C_NOT_ZERO, loop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (1)), (loop));

1222

never executed: }

1223 } -

1224 -

1225 static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket) -

1226 { -

1227

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1228

struct sljit_jump *earlyexit;

executed (the execution status of this line is deduced): struct sljit_label *loop;

1229

executed (the execution status of this line is deduced): struct sljit_jump *earlyexit;

1230 -

1231 /* At this point we can freely use all registers. */ -

1232

OP1(SLJIT_MOV, SLJIT_SAVED_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (8), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w))));

1233

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w))), (6), (0));

1234 -

1235

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, ARGUMENTS, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

1236

OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsetcount));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (12), (2), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->offsetcount) - 0x10)));

1237

OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));

executed (the execution status of this line is deduced):

sljit_emit_op2(compiler, (25), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->offsets) - 0x10)), (0x200), (sizeof(int)));

1238

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, begin));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

1239

OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (11), (0), (0x200), ((8 * sizeof(sljit_w))));

1240 /* Unlikely, but possible */ -

1241

earlyexit = CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 0);

executed (the execution status of this line is deduced): earlyexit = sljit_emit_cmp(compiler, (0), (2), (0), (0x200), (0));

1242

OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_TEMPORARY_REG1, 0);

executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

1243

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (7), (0), ((0x100 | (6))), (0), (1), (0));

1244

OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_w));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (sizeof(sljit_w)));

1245 /* Copy the integer value to the output buffer */ -

1246 #ifdef COMPILE_PCRE16 -

1247

OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (33), (7), (0), (7), (0), (0x200), (1));

1248 #endif -

1249

OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (19), ((0x100 | (3))), (sizeof(int)), (7), (0));

1250

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (2), (0), (2), (0), (0x200), (1));

1251

JUMPTO(SLJIT_C_NOT_ZERO, loop);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (1)), (loop));

1252

JUMPHERE(earlyexit);

executed (the execution status of this line is deduced): sljit_set_label((earlyexit), sljit_emit_label(compiler));

1253 -

1254 /* Calculate the return value, which is the maximum ovector value. */ -

1255

if (topbracket > 1)

partially evaluated: topbracket > 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1256 { -

1257

OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (23), (1), (0), (11), (0), (0x200), ((8 * sizeof(sljit_w)) + topbracket * 2 * sizeof(sljit_w)));

1258

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, topbracket + 1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), (0x200), (topbracket + 1));

1259 -

1260 /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */ -

1261

OP1(SLJIT_MOVU, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), -(2 * (sljit_w)sizeof(sljit_w)));

never executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

1262

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (13), (3), (0), ((0x100 | (1))), (-(2 * (sljit_w)sizeof(sljit_w))));

1263

OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (2), (0), (2), (0), (0x200), (1));

1264

CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG3, 0, loop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (0), (3), (0), (8), (0)), (loop));

1265

OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (2), (0));

1266

OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);

never executed: }

1267 else -

1268

executed: sljit_emit_op1(compiler, (6), (1), (0), (0x200), (1));

Execution Count:15

1269 } -

1270 -

1271 static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar* cc) -

1272 { -

1273 /* Detects if the character has an othercase. */ -

1274

unsigned int c;

never executed (the execution status of this line is deduced): unsigned int c;

1275 -

1276 #ifdef SUPPORT_UTF -

1277

return c != UCD_OTHERCASE(c);

never evaluated: common->utf

1278 { -

1279

GETCHAR(c, cc);

never executed: }

never evaluated: (c & 0xfc00) == 0xd800

1280

if (c > 127)

never evaluated: c > 127

1281 { -

1282 #ifdef SUPPORT_UCP -

1283

never executed:

return c != (c + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128])->other_case);

1284 #else -

1285 return FALSE; -

1286 #endif -

1287 } -

1288 #ifndef COMPILE_PCRE8 -

1289

return common->fcc[c] != c;

never executed: return common->fcc[c] != c;

1290 #endif -

1291 } -

1292 else -

1293 #endif -

1294

return MAX_255(c) ? common->fcc[c] != c : FALSE;

never executed: c = *cc;

1295

never executed: return ((c) <= 255u) ? common->fcc[c] != c : 0;

1296 } -

1297 -

1298 static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c) -

1299 { -

1300 /* Returns with the othercase. */ -

1301 #ifdef SUPPORT_UTF -

1302

if (common->utf && c > 127)

never evaluated: common->utf

never evaluated: c > 127

1303 { -

1304 #ifdef SUPPORT_UCP -

1305

return UCD_OTHERCASE(c);

never executed: return (c + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128])->other_case);

1306 #else -

1307 return c; -

1308 #endif -

1309 } -

1310 #endif -

1311

return TABLE_GET(c, common->fcc, c);

never executed: return (((c) <= 255u)? ((common->fcc)[c]):(c));

1312 } -

1313 -

1314 static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar* cc) -

1315 { -

1316 /* Detects if the character and its othercase has only 1 bit difference. */ -

1317

unsigned int c, oc, bit;

never executed (the execution status of this line is deduced): unsigned int c, oc, bit;

1318 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

1319 int n; -

1320 #endif -

1321 -

1322 #ifdef SUPPORT_UTF -

1323

never evaluated: common->utf

1324 { -

1325

GETCHAR(c, cc);

never executed: }

never evaluated: (c & 0xfc00) == 0xd800

1326

if (c <= 127)

never evaluated: c <= 127

1327

oc = common->fcc[c];

never executed: oc = common->fcc[c];

1328 else -

1329 { -

1330 #ifdef SUPPORT_UCP -

1331

oc = UCD_OTHERCASE(c);

never executed (the execution status of this line is deduced): oc = (c + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c) / 128] * 128 + (c) % 128])->other_case);

1332 #else -

1333 oc = c; -

1334 #endif -

1335

never executed: }

1336 } -

1337 else -

1338 { -

1339

oc = TABLE_GET(c, common->fcc, c);

never executed (the execution status of this line is deduced): c = *cc;

1340

never evaluated: ((c) <= 255u)

1341

if (c <= 127 && bit == 0x20)

never executed: }

1342 #else -

1343 c = *cc; -

1344 oc = TABLE_GET(c, common->fcc, c); -

1345 #endif -

1346 -

1347

SLJIT_ASSERT(c != oc);

never executed: }

never evaluated: 0

1348 -

1349

bit = c ^ oc;

never executed (the execution status of this line is deduced): bit = c ^ oc;

1350 /* Optimized for English alphabet. */ -

1351

never evaluated: c <= 127

never evaluated: bit == 0x20

1352

return (0 << 8) | 0x20;

never executed: return (0 << 8) | 0x20;

1353 -

1354 /* Since c != oc, they must have at least 1 bit difference. */ -

1355

if (!ispowerof2(bit))

never evaluated: !ispowerof2(bit)

1356

return 0;

never executed: return 0;

1357 -

1358 #ifdef COMPILE_PCRE8 -

1359 -

1360 #ifdef SUPPORT_UTF -

1361 if (common->utf && c > 127) -

1362 { -

1363 n = GET_EXTRALEN(*cc); -

1364 while ((bit & 0x3f) == 0) -

1365 { -

1366 n--; -

1367 bit >>= 6; -

1368 } -

1369 return (n << 8) | bit; -

1370 } -

1371 #endif /* SUPPORT_UTF */ -

1372 return (0 << 8) | bit; -

1373 -

1374 #else /* COMPILE_PCRE8 */ -

1375 -

1376 #ifdef COMPILE_PCRE16 -

1377 #ifdef SUPPORT_UTF -

1378

if (common->utf && c > 65535)

never evaluated: common->utf

never evaluated: c > 65535

1379 { -

1380

if (bit >= (1 << 10))

never evaluated: bit >= (1 << 10)

1381

bit >>= 10;

never executed: bit >>= 10;

1382 else -

1383

return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));

never executed: return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));

1384 } -

1385 #endif /* SUPPORT_UTF */ -

1386

return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));

never executed: return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));

1387 #endif /* COMPILE_PCRE16 */ -

1388 -

1389 #endif /* COMPILE_PCRE8 */ -

1390 } -

1391 -

1392 static SLJIT_INLINE void check_input_end(compiler_common *common, jump_list **fallbacks) -

1393 { -

1394

add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1395

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (3), (6), (0), (7), (0)));

1396

executed: }

Execution Count:6

1397 -

1398 static void read_char(compiler_common *common) -

1399 { -

1400 /* Reads the character into TMP1, updates STR_PTR. -

1401 Does not check STR_END. TMP2 Destroyed. */ -

1402

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1403 #ifdef SUPPORT_UTF -

1404

executed (the execution status of this line is deduced): struct sljit_jump *jump;

1405 #endif -

1406 -

1407

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

1408 #ifdef SUPPORT_UTF -

1409

jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:10	no Evaluation Count:0

0-10

1410 { -

1411 #ifdef COMPILE_PCRE8 -

1412 jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0); -

1413 #else -

1414 #ifdef COMPILE_PCRE16 -

1415

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xd800));

1416 #endif -

1417 #endif /* COMPILE_PCRE8 */ -

1418

add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));

executed (the execution status of this line is deduced): add_jump(compiler, &common->utfreadchar, sljit_emit_jump(compiler, (23)));

1419

executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

1420

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed: }

Execution Count:10

1421 #endif -

1422

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1423

executed: }

Execution Count:10

1424 -

1425 static void peek_char(compiler_common *common) -

1426 { -

1427 /* Reads the character into TMP1, keeps STR_PTR. -

1428 Does not check STR_END. TMP2 Destroyed. */ -

1429

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1430 #ifdef SUPPORT_UTF -

1431

executed (the execution status of this line is deduced): struct sljit_jump *jump;

1432 #endif -

1433 -

1434

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

1435 #ifdef SUPPORT_UTF -

1436

jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

1437 { -

1438 #ifdef COMPILE_PCRE8 -

1439 jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0); -

1440 #else -

1441 #ifdef COMPILE_PCRE16 -

1442

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xd800));

1443 #endif -

1444 #endif /* COMPILE_PCRE8 */ -

1445

add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));

executed (the execution status of this line is deduced): add_jump(compiler, &common->utfreadchar, sljit_emit_jump(compiler, (23)));

1446

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (3), (0));

1447

executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

1448

executed: }

Execution Count:1

1449 #endif -

1450

executed: }

Execution Count:1

1451 -

1452 static void read_char8_type(compiler_common *common) -

1453 { -

1454 /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */ -

1455

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1456 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

1457

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

1458 #endif -

1459 -

1460 #ifdef SUPPORT_UTF -

1461

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);

never evaluated: common->utf

1462 { -

1463

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (0));

1464

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1465 #ifdef COMPILE_PCRE8 -

1466 /* This can be an extra read in some situations, but hopefully -

1467 it is needed in most cases. */ -

1468 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); -

1469 jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0); -

1470 add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL)); -

1471 JUMPHERE(jump); -

1472 #else -

1473 #ifdef COMPILE_PCRE16 -

1474

OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), (0));

1475

jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (3), (0), (0x200), (255));

1476

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (3))), (common->ctypes));

1477

OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

1478 /* Skip low surrogate if necessary. */ -

1479

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (3), (0), (3), (0), (0x200), (0xfc00));

1480

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (3), (0), (0x200), (0xd800));

1481

OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

1482

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (3), (0), (0x200), (1));

1483

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (3), (0));

1484 #endif -

1485 #endif /* COMPILE_PCRE8 */ -

1486

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);

never executed: return;

1487 } -

1488 #endif -

1489

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (0));

1490

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1491 #ifdef COMPILE_PCRE16 -

1492 /* The ctypes array contains only 256 values. */ -

1493

OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), (0));

1494

jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (3), (0), (0x200), (255));

1495 #endif -

1496

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (3))), (common->ctypes));

1497 #ifdef COMPILE_PCRE16 -

1498

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

1499 #endif -

1500

never executed: }

1501 -

1502 static void skip_char_back(compiler_common *common) -

1503 { -

1504 /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */ -

1505

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1506 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

1507 struct sljit_label *label; -

1508 -

1509 if (common->utf) -

1510 { -

1511 label = LABEL(); -

1512 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1)); -

1513 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); -

1514 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0); -

1515 CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label); -

1516 return; -

1517 } -

1518 #endif -

1519 #if defined SUPPORT_UTF && defined COMPILE_PCRE16 -

1520

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

0-12

1521 { -

1522

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (-((1) << 1)));

1523

OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (0x200), (((1) << 1)));

1524 /* Skip low surrogate if necessary. */ -

1525

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (0xfc00));

1526

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0xdc00));

1527

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

1528

OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

1529

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (1), (0));

1530

OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed: return;

Execution Count:12

1531 } -

1532 #endif -

1533

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (0x200), (((1) << 1)));

1534

never executed: }

1535 -

1536 static void check_newlinechar(compiler_common *common, int nltype, jump_list **fallbacks, BOOL jumpiftrue) -

1537 { -

1538 /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */ -

1539

if (nltype == NLTYPE_ANY)

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1540 -

1541

partially evaluated: nltype == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6

0-6

1542 { -

1543

add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->anynewline, sljit_emit_jump(compiler, (23)));

1544

add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (jumpiftrue ? 1 : 0)));

1545

else if (nltype == NLTYPE_ANYCRLF)

never executed: }

1546

evaluated: nltype == 2

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:4

2-4

1547 { -

1548

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), ('\015'));

1549

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

1550

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), ('\012'));

1551

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

1552

add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (jumpiftrue ? 1 : 0)));

1553

SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);

executed: }

Execution Count:2

1554 else -

1555 { -

1556

executed: }

Execution Count:4

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

0-4

1557

add_jump(compiler, fallbacks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (jumpiftrue ? 0 : 1), (1), (0), (0x200), (common->newline)));

1558

executed: }

Execution Count:4

1559 } -

1560 -

1561 #ifdef SUPPORT_UTF -

1562 -

1563 #ifdef COMPILE_PCRE8 -

1564 static void do_utfreadchar(compiler_common *common) -

1565 { -

1566 /* Fast decoding a UTF-8 character. TMP1 contains the first byte -

1567 of the character (>= 0xc0). Return char value in TMP1, length - 1 in TMP2. */ -

1568 DEFINE_COMPILER; -

1569 struct sljit_jump *jump; -

1570 -

1571 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize); -

1572 /* Searching for the first zero. */ -

1573 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20); -

1574 jump = JUMP(SLJIT_C_NOT_ZERO); -

1575 /* Two byte sequence. */ -

1576 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); -

1577 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); -

1578 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f); -

1579 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6); -

1580 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); -

1581 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); -

1582 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1)); -

1583 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); -

1584 JUMPHERE(jump); -

1585 -

1586 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10); -

1587 jump = JUMP(SLJIT_C_NOT_ZERO); -

1588 /* Three byte sequence. */ -

1589 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); -

1590 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f); -

1591 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12); -

1592 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); -

1593 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); -

1594 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); -

1595 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2)); -

1596 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2)); -

1597 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); -

1598 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); -

1599 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2)); -

1600 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); -

1601 JUMPHERE(jump); -

1602 -

1603 /* Four byte sequence. */ -

1604 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1)); -

1605 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07); -

1606 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18); -

1607 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); -

1608 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12); -

1609 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); -

1610 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2)); -

1611 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); -

1612 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); -

1613 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); -

1614 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3)); -

1615 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3)); -

1616 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f); -

1617 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0); -

1618 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3)); -

1619 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); -

1620 } -

1621 -

1622 static void do_utfreadtype8(compiler_common *common) -

1623 { -

1624 /* Fast decoding a UTF-8 character type. TMP2 contains the first byte -

1625 of the character (>= 0xc0). Return value in TMP1. */ -

1626 DEFINE_COMPILER; -

1627 struct sljit_jump *jump; -

1628 struct sljit_jump *compare; -

1629 -

1630 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize); -

1631 -

1632 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20); -

1633 jump = JUMP(SLJIT_C_NOT_ZERO); -

1634 /* Two byte sequence. */ -

1635 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0)); -

1636 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); -

1637 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f); -

1638 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6); -

1639 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f); -

1640 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0); -

1641 compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255); -

1642 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes); -

1643 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); -

1644 -

1645 JUMPHERE(compare); -

1646 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0); -

1647 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); -

1648 JUMPHERE(jump); -

1649 -

1650 /* We only have types for characters less than 256. */ -

1651 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(utf8_table4) - 0xc0); -

1652 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); -

1653 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0); -

1654 sljit_emit_fast_return(compiler, RETURN_ADDR, 0); -

1655 } -

1656 -

1657 #else /* COMPILE_PCRE8 */ -

1658 -

1659 #ifdef COMPILE_PCRE16 -

1660 static void do_utfreadchar(compiler_common *common) -

1661 { -

1662 /* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char -

1663 of the character (>= 0xd800). Return char value in TMP1, length - 1 in TMP2. */ -

1664

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1665

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

executed (the execution status of this line is deduced): struct sljit_jump *jump;

1666 -

1667

executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

1668

jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xdc00);

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xdc00));

1669 /* Do nothing, only return. */ -

1670

executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

1671 -

1672

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));

executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

1673 /* Combine two 16 bit characters. */ -

1674

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (((1) << 1)));

1675

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1676

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (0x3ff));

1677

OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 10);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (10));

1678

OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3ff);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (3), (0), (3), (0), (0x200), (0x3ff));

1679

OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (29), (1), (0), (1), (0), (3), (0));

1680

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (((1) << 1)));

1681

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (0x10000));

1682

executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

1683

executed: }

Execution Count:7

1684 #endif /* COMPILE_PCRE16 */ -

1685 -

1686 #endif /* COMPILE_PCRE8 */ -

1687 -

1688 #endif /* SUPPORT_UTF */ -

1689 -

1690 #ifdef SUPPORT_UCP -

1691 -

1692 /* UCD_BLOCK_SIZE must be 128 (see the assert below). */ -

1693 #define UCD_BLOCK_MASK 127 -

1694 #define UCD_BLOCK_SHIFT 7 -

1695 -

1696 static void do_getucd(compiler_common *common) -

1697 { -

1698 /* Search the UCD record for the character comes in TMP1. -

1699 Returns chartype in TMP1 and UCD offset in TMP2. */ -

1700

SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1701 -

1702

never executed: }

never evaluated: 0

1703 -

1704

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

1705

OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (32), (3), (0), (1), (0), (0x200), (7));

1706

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(ucd_stage1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (3))), ((sljit_w)_pcre16_ucd_stage1));

1707

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (127));

1708

OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (3), (0), (0x200), (7));

1709

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (3), (0));

1710

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_stage2));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), ((sljit_w)_pcre16_ucd_stage2));

1711

OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (3) | ((1) << 4))), (1));

1712

OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));

never executed (the execution status of this line is deduced):

sljit_emit_op1(compiler, (6), (1), (0), (0x200), ((sljit_w)_pcre16_ucd_records + ((sljit_w)(&((ucd_record*)0x10)->chartype) - 0x10)));

1713

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (1) | ((3) << 4))), (3));

1714

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

1715

never executed: }

1716 #endif -

1717 -

1718 static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf, BOOL firstline) -

1719 { -

1720

struct sljit_label *mainloop;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1721

executed (the execution status of this line is deduced): struct sljit_label *mainloop;

1722

struct sljit_label *newlinelabel = NULL;

executed (the execution status of this line is deduced): struct sljit_label *newlinelabel = ((void *)0);

1723

struct sljit_jump *start;

executed (the execution status of this line is deduced): struct sljit_jump *start;

1724

struct sljit_jump *end = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *end = ((void *)0);

1725

struct sljit_jump *nl = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *nl = ((void *)0);

1726 #ifdef SUPPORT_UTF -

1727

struct sljit_jump *singlechar;

executed (the execution status of this line is deduced): struct sljit_jump *singlechar;

1728 #endif -

1729

jump_list *newline = NULL;

executed (the execution status of this line is deduced): jump_list *newline = ((void *)0);

1730

BOOL newlinecheck = FALSE;

executed (the execution status of this line is deduced): BOOL newlinecheck = 0;

1731

BOOL readuchar = FALSE;

executed (the execution status of this line is deduced): BOOL readuchar = 0;

1732 -

1733

if (!(hascrorlf || firstline) && (common->nltype == NLTYPE_ANY ||

partially evaluated: hascrorlf

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: common->nltype == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1734

common->nltype == NLTYPE_ANYCRLF || common->newline > 255))

evaluated: common->nltype == 2

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

evaluated: common->newline > 255

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:12

1-14

1735

newlinecheck = TRUE;

executed: newlinecheck = 1;

Execution Count:3

1736 -

1737

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STR_PTR, 0);

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

1738 { -

1739 /* Search for the end of the first line. */ -

1740

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((0 * sizeof(sljit_w))), (6), (0));

1741

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_END, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((7 * sizeof(sljit_w))), (7), (0));

1742 -

1743

if (common->nltype == NLTYPE_FIXED && common->newline > 255)

never evaluated: common->nltype == 0

never evaluated: common->newline > 255

1744 { -

1745

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): mainloop = sljit_emit_label(compiler);

1746

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1747

end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed (the execution status of this line is deduced): end = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1748

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((-1) << 1)));

1749

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (((0) << 1)));

1750

CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ((common->newline >> 8) & 0xff)), (mainloop));

1751

CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (common->newline & 0xff)), (mainloop));

1752

OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), ((0x100 | (11))), ((7 * sizeof(sljit_w))), (6), (0), (0x200), (((1) << 1)));

1753

end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed: }

1754 else -

1755 { -

1756

never executed (the execution status of this line is deduced): end = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1757

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);

never executed (the execution status of this line is deduced): mainloop = sljit_emit_label(compiler);

1758 /* Continual stores does not cause data dependency. */ -

1759

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((7 * sizeof(sljit_w))), (6), (0));

1760

check_newlinechar(common, common->nltype, &newline, TRUE);

never executed (the execution status of this line is deduced): read_char(common);

1761

never executed (the execution status of this line is deduced): check_newlinechar(common, common->nltype, &newline, 1);

1762

CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (6), (0), (7), (0)), (mainloop));

1763

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((7 * sizeof(sljit_w))), (6), (0));

1764

set_jumps(newline, LABEL());

never executed (the execution status of this line is deduced): set_jumps(newline, sljit_emit_label(compiler));

1765

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);

never executed: }

1766 -

1767

JUMPHERE(end);

never executed (the execution status of this line is deduced): sljit_set_label((end), sljit_emit_label(compiler));

1768

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), ((0 * sizeof(sljit_w))));

1769

start = JUMP(SLJIT_JUMP);

never executed: }

1770 -

1771

executed (the execution status of this line is deduced): start = sljit_emit_jump(compiler, (22));

1772 -

1773

if (newlinecheck)

evaluated: newlinecheck

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:12

3-12

1774 { -

1775

newlinelabel = LABEL();

executed (the execution status of this line is deduced): newlinelabel = sljit_emit_label(compiler);

1776

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1777

end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): end = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1778

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

1779

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (common->newline & 0xff));

1780

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

1781 #ifdef COMPILE_PCRE16 -

1782

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

1783 #endif -

1784

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (1), (0));

1785

nl = JUMP(SLJIT_JUMP);

executed (the execution status of this line is deduced): nl = sljit_emit_jump(compiler, (22));

1786

executed: }

Execution Count:3

1787 -

1788

if (common->utf) readuchar = TRUE;

executed (the execution status of this line is deduced): mainloop = sljit_emit_label(compiler);

1789 -

1790 /* Increasing the STR_PTR here requires one less jump in the most common case. */ -

1791 #ifdef SUPPORT_UTF -

1792

executed: readuchar = 1;

Execution Count:15

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1793 #endif -

1794

if (newlinecheck) readuchar = TRUE;

executed: readuchar = 1;

Execution Count:3

evaluated: newlinecheck

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:12

3-12

1795 -

1796

if (readuchar)

partially evaluated: readuchar

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1797

CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);

executed: sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

Execution Count:15

1798 -

1799

if (newlinecheck)

evaluated: newlinecheck

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:12

3-12

1800

executed: sljit_set_label(sljit_emit_cmp(compiler, (0), (1), (0), (0x200), ((common->newline >> 8) & 0xff)), (newlinelabel));

Execution Count:3

1801 -

1802

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1803 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

1804 if (common->utf) -

1805 { -

1806 singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0); -

1807 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0); -

1808 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); -

1809 JUMPHERE(singlechar); -

1810 } -

1811 #endif -

1812 #if defined SUPPORT_UTF && defined COMPILE_PCRE16 -

1813

singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

1814 { -

1815

executed (the execution status of this line is deduced): singlechar = sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xd800));

1816

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (0xfc00));

1817

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0xd800));

1818

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

1819

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

1820

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (1), (0));

1821

JUMPHERE(singlechar);

executed (the execution status of this line is deduced): sljit_set_label((singlechar), sljit_emit_label(compiler));

1822

executed: }

Execution Count:15

1823 #endif -

1824

JUMPHERE(start);

executed (the execution status of this line is deduced): sljit_set_label((start), sljit_emit_label(compiler));

1825 -

1826

if (newlinecheck)

evaluated: newlinecheck

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:12

3-12

1827 { -

1828

JUMPHERE(end);

executed (the execution status of this line is deduced): sljit_set_label((end), sljit_emit_label(compiler));

1829

JUMPHERE(nl);

executed (the execution status of this line is deduced): sljit_set_label((nl), sljit_emit_label(compiler));

1830

executed: }

Execution Count:3

1831 -

1832

return mainloop;

executed: return mainloop;

Execution Count:15

1833 } -

1834 -

1835 static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline) -

1836 { -

1837

struct sljit_label *start;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1838

executed (the execution status of this line is deduced): struct sljit_label *start;

1839

struct sljit_jump *leave;

executed (the execution status of this line is deduced): struct sljit_jump *leave;

1840

struct sljit_jump *found;

executed (the execution status of this line is deduced): struct sljit_jump *found;

1841

pcre_uchar oc, bit;

executed (the execution status of this line is deduced): pcre_uchar oc, bit;

1842 -

1843

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6

0-6

1844 { -

1845

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (7), (0));

1846

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((7 * sizeof(sljit_w))));

1847

leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed: }

1848 -

1849

start = LABEL();

executed (the execution status of this line is deduced): start = sljit_emit_label(compiler);

1850

executed (the execution status of this line is deduced): leave = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1851

oc = TABLE_GET(first_char, common->fcc, first_char);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

1852 -

1853

oc = first_char;

executed (the execution status of this line is deduced): oc = first_char;

1854

if (caseless)

partially evaluated: caseless

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6

0-6

1855 { -

1856

never evaluated: ((first_char) <= 255u)

1857 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8) -

1858

if (first_char > 127 && common->utf)

never evaluated: first_char > 127

never evaluated: common->utf

1859

oc = UCD_OTHERCASE(first_char);

never executed:

oc = (first_char + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(first_char) / 128] * 128 + (first_char) % 128])->other_case);

1860 #endif -

1861

found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, first_char);

never executed: }

1862

if (first_char == oc)

partially evaluated: first_char == oc

TRUE	FALSE
yes Evaluation Count:6	no Evaluation Count:0

0-6

1863

executed: found = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (first_char));

Execution Count:6

1864 else -

1865 { -

1866

bit = first_char ^ oc;

never executed (the execution status of this line is deduced): bit = first_char ^ oc;

1867

if (ispowerof2(bit))

never evaluated: ispowerof2(bit)

1868 { -

1869

OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (29), (3), (0), (1), (0), (0x200), (bit));

1870

found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);

never executed (the execution status of this line is deduced): found = sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (first_char | bit));

1871

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);

never executed: }

1872 else -

1873 { -

1874

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (first_char));

1875

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

1876

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (oc));

1877

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

1878

found = JUMP(SLJIT_C_NOT_ZERO);

never executed (the execution status of this line is deduced): found = sljit_emit_jump(compiler, (1));

1879

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed: }

1880 } -

1881 -

1882

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1883 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

1884 if (common->utf) -

1885 { -

1886 CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start); -

1887 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0); -

1888 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); -

1889 } -

1890 #endif -

1891 #if defined SUPPORT_UTF && defined COMPILE_PCRE16 -

1892

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:6	no Evaluation Count:0

0-6

1893 { -

1894

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xd800)), (start));

1895

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (0xfc00));

1896

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0xd800));

1897

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

1898

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

1899

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (1), (0));

1900

JUMPTO(SLJIT_JUMP, start);

executed: }

Execution Count:6

1901 #endif -

1902

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (start));

1903

JUMPHERE(found);

executed (the execution status of this line is deduced): sljit_set_label((found), sljit_emit_label(compiler));

1904

executed (the execution status of this line is deduced): sljit_set_label((leave), sljit_emit_label(compiler));

1905 -

1906

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6

0-6

1907

never executed: sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

1908

executed: }

Execution Count:6

1909 -

1910 static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline) -

1911 { -

1912

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1913

struct sljit_jump *lastchar;

executed (the execution status of this line is deduced): struct sljit_label *loop;

1914

executed (the execution status of this line is deduced): struct sljit_jump *lastchar;

1915

struct sljit_jump *firstchar;

executed (the execution status of this line is deduced): struct sljit_jump *firstchar;

1916

struct sljit_jump *leave;

executed (the execution status of this line is deduced): struct sljit_jump *leave;

1917

struct sljit_jump *foundcr = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *foundcr = ((void *)0);

1918

struct sljit_jump *notfoundnl;

executed (the execution status of this line is deduced): struct sljit_jump *notfoundnl;

1919

jump_list *newline = NULL;

executed (the execution status of this line is deduced): jump_list *newline = ((void *)0);

1920 -

1921

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

0-5

1922 { -

1923

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (7), (0));

1924

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((7 * sizeof(sljit_w))));

1925

if (common->nltype == NLTYPE_FIXED && common->newline > 255)

never executed: }

1926 -

1927

evaluated: common->nltype == 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:1

evaluated: common->newline > 255

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:2

1-4

1928 { -

1929

lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): lastchar = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1930

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

1931

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->str) - 0x10)));

1932

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

1933

firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);

executed (the execution status of this line is deduced): firstchar = sljit_emit_cmp(compiler, (5), (6), (0), (3), (0));

1934 -

1935

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (((2) << 1)));

1936

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (6), (0), (1), (0));

1937

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER_EQUAL);

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (3));

1938 #ifdef COMPILE_PCRE16 -

1939

OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (3), (0), (0x200), (1));

1940 #endif -

1941

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (3), (0));

1942 -

1943

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

1944

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

1945

leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): leave = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1946

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((-2) << 1)));

1947

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (((-1) << 1)));

1948

CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ((common->newline >> 8) & 0xff)), (loop));

1949

CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (common->newline & 0xff)), (loop));

1950 -

1951

executed (the execution status of this line is deduced): sljit_set_label((leave), sljit_emit_label(compiler));

1952

JUMPHERE(firstchar);

executed (the execution status of this line is deduced): sljit_set_label((firstchar), sljit_emit_label(compiler));

1953

JUMPHERE(lastchar);

executed (the execution status of this line is deduced): sljit_set_label((lastchar), sljit_emit_label(compiler));

1954 -

1955

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

1956

never executed: sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

1957

executed: return;

Execution Count:2

1958 } -

1959 -

1960

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

1961

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->str) - 0x10)));

1962

firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);

executed (the execution status of this line is deduced): firstchar = sljit_emit_cmp(compiler, (5), (6), (0), (3), (0));

1963

executed (the execution status of this line is deduced): skip_char_back(common);

1964 -

1965

executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

1966

lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): read_char(common);

1967

executed (the execution status of this line is deduced): lastchar = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1968

if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)

partially evaluated: common->nltype == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

evaluated: common->nltype == 2

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:2

0-3

1969

foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);

executed: foundcr = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), ('\015'));

Execution Count:1

1970

check_newlinechar(common, common->nltype, &newline, FALSE);

executed (the execution status of this line is deduced): check_newlinechar(common, common->nltype, &newline, 0);

1971

set_jumps(newline, loop);

executed (the execution status of this line is deduced): set_jumps(newline, loop);

1972 -

1973

if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)

partially evaluated: common->nltype == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

evaluated: common->nltype == 2

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:2

0-3

1974 { -

1975

leave = JUMP(SLJIT_JUMP);

executed (the execution status of this line is deduced): leave = sljit_emit_jump(compiler, (22));

1976

JUMPHERE(foundcr);

executed (the execution status of this line is deduced): sljit_set_label((foundcr), sljit_emit_label(compiler));

1977

notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): notfoundnl = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

1978

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

1979

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), ('\012'));

1980

executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

1981 #ifdef COMPILE_PCRE16 -

1982

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

1983 #endif -

1984

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (1), (0));

1985

JUMPHERE(notfoundnl);

executed (the execution status of this line is deduced): sljit_set_label((notfoundnl), sljit_emit_label(compiler));

1986

executed (the execution status of this line is deduced): sljit_set_label((leave), sljit_emit_label(compiler));

1987

executed: }

Execution Count:1

1988

JUMPHERE(lastchar);

executed (the execution status of this line is deduced): sljit_set_label((lastchar), sljit_emit_label(compiler));

1989

JUMPHERE(firstchar);

executed (the execution status of this line is deduced): sljit_set_label((firstchar), sljit_emit_label(compiler));

1990 -

1991

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

partially evaluated: firstline

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3

0-3

1992

never executed: sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

1993

executed: }

Execution Count:3

1994 -

1995 static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline) -

1996 { -

1997

struct sljit_label *start;

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

1998

never executed (the execution status of this line is deduced): struct sljit_label *start;

1999

struct sljit_jump *leave;

never executed (the execution status of this line is deduced): struct sljit_jump *leave;

2000

struct sljit_jump *found;

never executed (the execution status of this line is deduced): struct sljit_jump *found;

2001 #ifndef COMPILE_PCRE8 -

2002

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

2003 #endif -

2004 -

2005

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);

never evaluated: firstline

2006 { -

2007

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (7), (0));

2008

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((7 * sizeof(sljit_w))));

2009

leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed: }

2010 -

2011

start = LABEL();

never executed (the execution status of this line is deduced): start = sljit_emit_label(compiler);

2012

never executed (the execution status of this line is deduced): leave = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

2013

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

2014 #ifdef SUPPORT_UTF -

2015

OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);

never evaluated: common->utf

2016

never executed: sljit_emit_op1(compiler, (6), (5), (0), (1), (0));

2017 #endif -

2018 #ifndef COMPILE_PCRE8 -

2019

jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (255));

2020

OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), (255));

2021

OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2022 #endif -

2023

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (3), (0), (1), (0), (0x200), (0x7));

2024

OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (32), (1), (0), (1), (0), (0x200), (3));

2025

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), start_bits);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (1))), (start_bits));

2026

OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (0x200), (1), (3), (0));

2027

OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28 | 0x0200), (0), (0), (1), (0), (3), (0));

2028

found = JUMP(SLJIT_C_NOT_ZERO);

never executed (the execution status of this line is deduced): found = sljit_emit_jump(compiler, (1));

2029 -

2030 #ifdef SUPPORT_UTF -

2031

never evaluated: common->utf

2032

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed: sljit_emit_op1(compiler, (6), (1), (0), (5), (0));

2033 #endif -

2034

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

2035 #if defined SUPPORT_UTF && defined COMPILE_PCRE8 -

2036 if (common->utf) -

2037 { -

2038 CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start); -

2039 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0); -

2040 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); -

2041 } -

2042 #endif -

2043 #if defined SUPPORT_UTF && defined COMPILE_PCRE16 -

2044

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);

never evaluated: common->utf

2045 { -

2046

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xd800)), (start));

2047

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (0xfc00));

2048

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0xd800));

2049

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

2050

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

2051

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (1), (0));

2052

JUMPTO(SLJIT_JUMP, start);

never executed: }

2053 #endif -

2054

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (start));

2055

JUMPHERE(found);

never executed (the execution status of this line is deduced): sljit_set_label((found), sljit_emit_label(compiler));

2056

never executed (the execution status of this line is deduced): sljit_set_label((leave), sljit_emit_label(compiler));

2057 -

2058

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

never evaluated: firstline

2059

never executed: sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

2060

never executed: }

2061 -

2062 static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar) -

2063 { -

2064

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2065

struct sljit_jump *toolong;

never executed (the execution status of this line is deduced): struct sljit_label *loop;

2066

never executed (the execution status of this line is deduced): struct sljit_jump *toolong;

2067

struct sljit_jump *alreadyfound;

never executed (the execution status of this line is deduced): struct sljit_jump *alreadyfound;

2068

struct sljit_jump *found;

never executed (the execution status of this line is deduced): struct sljit_jump *found;

2069

struct sljit_jump *foundoc = NULL;

never executed (the execution status of this line is deduced): struct sljit_jump *foundoc = ((void *)0);

2070

struct sljit_jump *notfound;

never executed (the execution status of this line is deduced): struct sljit_jump *notfound;

2071

pcre_uchar oc, bit;

never executed (the execution status of this line is deduced): pcre_uchar oc, bit;

2072 -

2073

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_CHAR_PTR);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), ((6 * sizeof(sljit_w))));

2074

OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (6), (0), (0x200), (1000));

2075

toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);

never executed (the execution status of this line is deduced): toolong = sljit_emit_cmp(compiler, (2), (1), (0), (7), (0));

2076

alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);

never executed (the execution status of this line is deduced): alreadyfound = sljit_emit_cmp(compiler, (2), (6), (0), (3), (0));

2077 -

2078

if (has_firstchar)

never evaluated: has_firstchar

2079

OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed: sljit_emit_op2(compiler, (23), (1), (0), (6), (0), (0x200), (((1) << 1)));

2080 else -

2081

OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);

never executed: sljit_emit_op1(compiler, (6), (1), (0), (6), (0));

2082 -

2083

notfound = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, STR_END, 0);

never executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

2084

never executed (the execution status of this line is deduced): notfound = sljit_emit_cmp(compiler, (3), (1), (0), (7), (0));

2085 -

2086

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (1))), (0));

2087

oc = req_char;

never executed (the execution status of this line is deduced): oc = req_char;

2088

if (caseless)

never evaluated: caseless

2089 { -

2090

oc = TABLE_GET(req_char, common->fcc, req_char);

never evaluated: ((req_char) <= 255u)

2091 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8) -

2092

if (req_char > 127 && common->utf)

never evaluated: req_char > 127

never evaluated: common->utf

2093

oc = UCD_OTHERCASE(req_char);

never executed:

oc = (req_char + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(req_char) / 128] * 128 + (req_char) % 128])->other_case);

2094 #endif -

never executed: }

never evaluated: req_char == oc

2097

found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);

never executed: found = sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (req_char));

2098 else -

2099 { -

2100

bit = req_char ^ oc;

never executed (the execution status of this line is deduced): bit = req_char ^ oc;

2101

if (ispowerof2(bit))

never evaluated: ispowerof2(bit)

2102 { -

2103

OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (29), (3), (0), (3), (0), (0x200), (bit));

2104

found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);

never executed (the execution status of this line is deduced): found = sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (req_char | bit));

2105

found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);

never executed: }

2106 else -

2107 { -

2108

never executed (the execution status of this line is deduced): found = sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (req_char));

2109

foundoc = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, oc);

never executed (the execution status of this line is deduced): foundoc = sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (oc));

2110

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));

never executed: }

2111 } -

2112

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (((1) << 1)));

2113

JUMPTO(SLJIT_JUMP, loop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (loop));

2114 -

2115

JUMPHERE(found);

never executed (the execution status of this line is deduced): sljit_set_label((found), sljit_emit_label(compiler));

2116

if (foundoc)

never evaluated: foundoc

2117

JUMPHERE(foundoc);

never executed: sljit_set_label((foundoc), sljit_emit_label(compiler));

2118

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_CHAR_PTR, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((6 * sizeof(sljit_w))), (1), (0));

2119

JUMPHERE(alreadyfound);

never executed (the execution status of this line is deduced): sljit_set_label((alreadyfound), sljit_emit_label(compiler));

2120

JUMPHERE(toolong);

never executed (the execution status of this line is deduced): sljit_set_label((toolong), sljit_emit_label(compiler));

2121

return notfound;

never executed: return notfound;

2122 } -

2123 -

2124 static void do_revertframes(compiler_common *common) -

2125 { -

2126

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2127

struct sljit_label *mainloop;

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

2128

never executed (the execution status of this line is deduced): struct sljit_label *mainloop;

2129 -

2130

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

2131

OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (2), (0));

2132 -

2133 /* Drop frames until we reach STACK_TOP. */ -

2134

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);

never executed (the execution status of this line is deduced): mainloop = sljit_emit_label(compiler);

2135

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (0));

2136

jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (9), (3), (0), (0x200), (frame_end));

2137

OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_LOCALS_REG, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (3), (0), (3), (0), (11), (0));

2138

OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (3))), (0), ((0x100 | (1))), (sizeof(sljit_w)));

2139

OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_w), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (3))), (sizeof(sljit_w)), ((0x100 | (1))), (2 * sizeof(sljit_w)));

2140

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (3 * sizeof(sljit_w)));

2141

JUMPTO(SLJIT_JUMP, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (mainloop));

2142 -

2143

jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2144

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (frame_end));

2145 /* End of dropping frames. */ -

2146

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

2147 -

2148

jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2149

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (frame_setstrbegin));

2150 /* Set string begin. */ -

2151

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (sizeof(sljit_w)));

2152

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (2 * sizeof(sljit_w)));

2153

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), (3), (0));

2154

JUMPTO(SLJIT_JUMP, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (mainloop));

2155 -

2156

OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2157 /* Unknown command. */ -

2158

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (2 * sizeof(sljit_w)));

2159

JUMPTO(SLJIT_JUMP, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (mainloop));

2160

never executed: }

2161 -

2162 static void check_wordboundary(compiler_common *common) -

2163 { -

2164

struct sljit_jump *beginend;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2165

executed (the execution status of this line is deduced): struct sljit_jump *beginend;

2166 #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF -

2167

SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);

executed (the execution status of this line is deduced): struct sljit_jump *jump;

2168 #endif -

2169 -

2170

executed: }

Execution Count:1

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2171 -

2172

sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);

executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, (0x100 | (11)), (0 * sizeof(sljit_w)), 1, 5, 5, common->localsize);

2173 /* Get type of the previous char, and put it to LOCALS1. */ -

2174

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

2175

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

2176

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (0x200), (0));

2177

beginend = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);

executed (the execution status of this line is deduced): beginend = sljit_emit_cmp(compiler, (5), (6), (0), (1), (0));

2178

executed (the execution status of this line is deduced): skip_char_back(common);

2179

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): read_char(common);

2180 -

2181 /* Testing char type. */ -

2182 #ifdef SUPPORT_UCP -

2183

if (common->use_ucp)

partially evaluated: common->use_ucp

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2184 { -

2185

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (1));

2186

jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), ('\137'));

2187

add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->getucd, sljit_emit_jump(compiler, (23)));

2188

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (ucp_Ll));

2189

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (ucp_Lu - ucp_Ll));

2190

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (5));

2191

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (ucp_Nd - ucp_Ll));

2192

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (ucp_No - ucp_Nd));

2193

COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (5));

2194

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2195

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (3), (0));

2196

jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);

never executed: }

2197 else -

2198 #endif -

2199 { -

2200 #ifndef COMPILE_PCRE8 -

2201

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (1), (0), (0x200), (255));

2202 #elif defined SUPPORT_UTF -

2203 /* Here LOCALS1 has already been zeroed. */ -

2204 jump = NULL; -

2205 if (common->utf) -

2206 jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255); -

2207 #endif /* COMPILE_PCRE8 */ -

2208

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (1))), (common->ctypes));

2209

OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (32), (1), (0), (1), (0), (0x200), (4));

2210

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (1));

2211

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (1), (0));

2212 #ifndef COMPILE_PCRE8 -

2213

executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2214 #elif defined SUPPORT_UTF -

2215 if (jump != NULL) -

2216 JUMPHERE(jump); -

2217 #endif /* COMPILE_PCRE8 */ -

2218

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);

executed: }

Execution Count:1

2219

JUMPHERE(beginend);

executed (the execution status of this line is deduced): sljit_set_label((beginend), sljit_emit_label(compiler));

2220 -

2221

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (0));

2222

beginend = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): beginend = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

2223

peek_char(common);

executed (the execution status of this line is deduced): peek_char(common);

2224 -

2225 /* Testing char type. This is a code duplication. */ -

2226 #ifdef SUPPORT_UCP -

2227

if (common->use_ucp)

partially evaluated: common->use_ucp

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2228 { -

2229

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (1));

2230

jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), ('\137'));

2231

add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->getucd, sljit_emit_jump(compiler, (23)));

2232

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (ucp_Ll));

2233

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (ucp_Lu - ucp_Ll));

2234

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (5));

2235

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (ucp_Nd - ucp_Ll));

2236

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (ucp_No - ucp_Nd));

2237

COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (5));

2238

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2239

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);

never executed: }

2240 else -

2241 #endif -

2242 { -

2243 #ifndef COMPILE_PCRE8 -

2244 /* TMP2 may be destroyed by peek_char. */ -

2245

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (0));

2246

jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (1), (0), (0x200), (255));

2247 #elif defined SUPPORT_UTF -

2248 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0); -

2249 jump = NULL; -

2250 if (common->utf) -

2251 jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255); -

2252 #endif -

2253

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (1))), (common->ctypes));

2254

OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (32), (3), (0), (3), (0), (0x200), (4));

2255

OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (3), (0), (3), (0), (0x200), (1));

2256 #ifndef COMPILE_PCRE8 -

2257

executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2258 #elif defined SUPPORT_UTF -

2259 if (jump != NULL) -

2260 JUMPHERE(jump); -

2261 #endif /* COMPILE_PCRE8 */ -

2262

OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);

executed: }

Execution Count:1

2263

JUMPHERE(beginend);

executed (the execution status of this line is deduced): sljit_set_label((beginend), sljit_emit_label(compiler));

2264 -

2265

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (30 | 0x0200), (0), (0), (3), (0), ((0x100 | (11))), ((1 * sizeof(sljit_w))));

2266

sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);

executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, (0x100 | (11)), (0 * sizeof(sljit_w)));

2267

executed: }

Execution Count:1

2268 -

2269 static void check_anynewline(compiler_common *common) -

2270 { -

2271 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */ -

2272

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2273 -

2274

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

2275 -

2276

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (0x0a));

2277

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (0x0d - 0x0a));

2278

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (5));

2279

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x85 - 0x0a));

2280 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

2281 #ifdef COMPILE_PCRE8 -

2282 if (common->utf) -

2283 { -

2284 #endif -

2285

OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2286

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (29), (1), (0), (1), (0), (0x200), (0x1));

2287

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x2029 - 0x0a));

2288 #ifdef COMPILE_PCRE8 -

2289 } -

2290 #endif -

2291 #endif /* SUPPORT_UTF || COMPILE_PCRE16 */ -

2292

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

2293

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

2294

never executed: }

2295 -

2296 static void check_hspace(compiler_common *common) -

2297 { -

2298 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */ -

2299

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2300 -

2301

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

2302 -

2303

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x09));

2304

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

2305

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x20));

2306

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2307

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0xa0));

2308 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

2309 #ifdef COMPILE_PCRE8 -

2310 if (common->utf) -

2311 { -

2312 #endif -

2313

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2314

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x1680));

2315

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2316

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x180e));

2317

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2318

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (0x2000));

2319

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (0x200A - 0x2000));

2320

COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (5));

2321

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x202f - 0x2000));

2322

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2323

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x205f - 0x2000));

2324

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2325

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x3000 - 0x2000));

2326 #ifdef COMPILE_PCRE8 -

2327 } -

2328 #endif -

2329 #endif /* SUPPORT_UTF || COMPILE_PCRE16 */ -

2330

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

2331 -

2332

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

2333

never executed: }

2334 -

2335 static void check_vspace(compiler_common *common) -

2336 { -

2337 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */ -

2338

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2339 -

2340

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

2341 -

2342

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (0x0a));

2343

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (0x0d - 0x0a));

2344

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (5));

2345

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x85 - 0x0a));

2346 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

2347 #ifdef COMPILE_PCRE8 -

2348 if (common->utf) -

2349 { -

2350 #endif -

2351

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

2352

OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (29), (1), (0), (1), (0), (0x200), (0x1));

2353

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0x2029 - 0x0a));

2354 #ifdef COMPILE_PCRE8 -

2355 } -

2356 #endif -

2357 #endif /* SUPPORT_UTF || COMPILE_PCRE16 */ -

2358

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

2359 -

2360

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

2361

never executed: }

2362 -

2363 #define CHAR1 STR_END -

2364 #define CHAR2 STACK_TOP -

2365 -

2366 static void do_casefulcmp(compiler_common *common) -

2367 { -

2368

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2369

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

2370

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): struct sljit_label *label;

2371 -

2372

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

2373

OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (3), (0));

2374

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), (7), (0));

2375

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((0 * sizeof(sljit_w))), (2), (0));

2376

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (((1) << 1)));

2377

OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (0x200), (((1) << 1)));

2378 -

2379

OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

2380

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (16), (7), (0), ((0x100 | (1))), (((1) << 1)));

2381

OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (16), (2), (0), ((0x100 | (6))), (((1) << 1)));

2382

jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (1), (7), (0), (2), (0));

2383

OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (3), (0), (3), (0), (0x200), (((1) << 1)));

2384

JUMPTO(SLJIT_C_NOT_ZERO, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (1)), (label));

2385 -

2386

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2387

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

2388

OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (7), (0), (5), (0));

2389

OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), ((0 * sizeof(sljit_w))));

2390

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

2391

never executed: }

2392 -

2393 #define LCC_TABLE STACK_LIMIT -

2394 -

2395 static void do_caselesscmp(compiler_common *common) -

2396 { -

2397

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2398

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

2399

sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): struct sljit_label *label;

2400 -

2401

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 4, 0, 1, 5, 5, common->localsize);

2402

OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (3), (0));

2403 -

2404

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), (8), (0));

2405

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((0 * sizeof(sljit_w))), (7), (0));

2406

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, CHAR2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (2), (0));

2407

OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (8), (0), (0x200), (common->lcc));

2408

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (((1) << 1)));

2409

OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (0x200), (((1) << 1)));

2410 -

2411

OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

2412

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (16), (7), (0), ((0x100 | (1))), (((1) << 1)));

2413

OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (16), (2), (0), ((0x100 | (6))), (((1) << 1)));

2414 #ifndef COMPILE_PCRE8 -

2415

jump = CMP(SLJIT_C_GREATER, CHAR1, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (7), (0), (0x200), (255));

2416 #endif -

2417

OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (7), (0), ((0x100 | (8) | ((7) << 4))), (0));

2418 #ifndef COMPILE_PCRE8 -

2419

jump = CMP(SLJIT_C_GREATER, CHAR2, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2420

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (2), (0), (0x200), (255));

2421 #endif -

2422

OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (2), (0), ((0x100 | (8) | ((2) << 4))), (0));

2423 #ifndef COMPILE_PCRE8 -

2424

jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2425 #endif -

2426

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (1), (7), (0), (2), (0));

2427

OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (3), (0), (3), (0), (0x200), (((1) << 1)));

2428

JUMPTO(SLJIT_C_NOT_ZERO, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (1)), (label));

2429 -

2430

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2431

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

2432

OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (8), (0), (5), (0));

2433

OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (11))), ((0 * sizeof(sljit_w))));

2434

OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), ((1 * sizeof(sljit_w))));

2435

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, 4, 0);

2436

const pcre_uchar *src2 = args->ptr;

never executed: }

2437 -

2438 #undef LCC_TABLE -

2439 #undef CHAR1 -

2440 #undef CHAR2 -

2441 -

2442 #if defined SUPPORT_UTF && defined SUPPORT_UCP -

2443 -

2444 static const pcre_uchar *SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1) -

2445 { -

2446 /* This function would be ineffective to do in JIT level. */ -

2447

int c1, c2;

never executed (the execution status of this line is deduced): int c1, c2;

2448

never executed (the execution status of this line is deduced): const pcre_uchar *src2 = args->ptr;

2449

const pcre_uchar *end2 = args->end;

never executed (the execution status of this line is deduced): const pcre_uchar *end2 = args->end;

2450 -

2451

while (src1 < end1)

never evaluated: src1 < end1

2452 { -

2453

if (src2 >= end2)

never evaluated: src2 >= end2

2454

return 0;

never executed: return 0;

2455

GETCHARINC(c1, src1);

never executed: }

never evaluated: (c1 & 0xfc00) == 0xd800

2456

GETCHARINC(c2, src2);

never executed: }

never evaluated: (c2 & 0xfc00) == 0xd800

2457

if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return 0;

never executed: return 0;

never evaluated: c1 != c2

never evaluated: c1 != (c2 + (_pcre16_ucd_records + _pcre16_ucd_stage2[_pcre16_ucd_stage1[(c2) / 128] * 128 + (c2) % 128])->other_case)

never executed: }

never executed: return src2;

2460 } -

2461 -

2462 #endif /* SUPPORT_UTF && SUPPORT_UCP */ -

2463 -

2464 static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc, -

2465 compare_context* context, jump_list **fallbacks) -

2466 { -

2467

unsigned int othercasebit = 0;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2468

executed (the execution status of this line is deduced): unsigned int othercasebit = 0;

2469

pcre_uchar *othercasechar = NULL;

executed (the execution status of this line is deduced): pcre_uchar *othercasechar = ((void *)0);

2470 #ifdef SUPPORT_UTF -

2471

int utflength;

executed (the execution status of this line is deduced): int utflength;

2472 #endif -

2473 -

2474

if (caseless && char_has_othercase(common, cc))

partially evaluated: caseless

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

never evaluated: char_has_othercase(common, cc)

0-9

2475 { -

2476

othercasebit = char_get_othercase_bit(common, cc);

never executed (the execution status of this line is deduced): othercasebit = char_get_othercase_bit(common, cc);

2477

SLJIT_ASSERT(othercasebit);

never executed: }

never evaluated: 0

2478 /* Extracting bit difference info. */ -

2479 #ifdef COMPILE_PCRE8 -

2480 othercasechar = cc + (othercasebit >> 8); -

2481 othercasebit &= 0xff; -

2482 #else -

2483 #ifdef COMPILE_PCRE16 -

2484

othercasechar = cc + (othercasebit >> 9);

never executed (the execution status of this line is deduced): othercasechar = cc + (othercasebit >> 9);

2485

if ((othercasebit & 0x100) != 0)

never evaluated: (othercasebit & 0x100) != 0

2486

othercasebit = (othercasebit & 0xff) << 8;

never executed: othercasebit = (othercasebit & 0xff) << 8;

2487 else -

2488

othercasebit &= 0xff;

never executed: othercasebit &= 0xff;

2489 #endif -

2490 #endif -

2491 } -

2492 -

2493

if (context->sourcereg == -1)

partially evaluated: context->sourcereg == -1

TRUE	FALSE
yes Evaluation Count:9	no Evaluation Count:0

0-9

2494 { -

2495 #ifdef COMPILE_PCRE8 -

2496 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED -

2497 if (context->length >= 4) -

2498 OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2499 else if (context->length >= 2) -

2500 OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2501 else -

2502 #endif -

2503 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2504 #else -

2505 #ifdef COMPILE_PCRE16 -

2506 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED -

2507

if (context->length >= 4)

partially evaluated: context->length >= 4

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2508

OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);

never executed: sljit_emit_op1(compiler, (12), (1), (0), ((0x100 | (6))), (-context->length));

2509 else -

2510 #endif -

2511

OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);

executed: sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (-context->length));

Execution Count:9

2512 #endif -

2513 #endif /* COMPILE_PCRE8 */ -

2514

context->sourcereg = TMP2;

executed (the execution status of this line is deduced): context->sourcereg = 3;

2515

if (common->utf && HAS_EXTRALEN(*cc))

executed: }

Execution Count:9

2516 -

2517 #ifdef SUPPORT_UTF -

2518

utflength = 1;

executed (the execution status of this line is deduced): utflength = 1;

2519

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:9	no Evaluation Count:0

partially evaluated: (((*cc) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2520

utflength += GET_EXTRALEN(*cc);

never executed: utflength += 1;

2521 -

2522 do -

2523 { -

2524 #endif -

2525 -

2526

context->length -= IN_UCHARS(1);

executed (the execution status of this line is deduced): context->length -= ((1) << 1);

2527 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED -

2528 -

2529 /* Unaligned read is supported. */ -

2530

if (othercasebit != 0 && othercasechar == cc)

partially evaluated: othercasebit != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

never evaluated: othercasechar == cc

0-9

2531 { -

2532

context->c.asuchars[context->ucharptr] = *cc | othercasebit;

never executed (the execution status of this line is deduced): context->c.asuchars[context->ucharptr] = *cc | othercasebit;

2533

context->oc.asuchars[context->ucharptr] = othercasebit;

never executed (the execution status of this line is deduced): context->oc.asuchars[context->ucharptr] = othercasebit;

2534

context->c.asuchars[context->ucharptr] = *cc;

never executed: }

2535 else -

2536 { -

2537

executed (the execution status of this line is deduced): context->c.asuchars[context->ucharptr] = *cc;

2538

context->oc.asuchars[context->ucharptr] = 0;

executed (the execution status of this line is deduced): context->oc.asuchars[context->ucharptr] = 0;

2539

if (context->ucharptr >= 2 || context->length == 0)

executed: }

Execution Count:9

2540

context->ucharptr++;

executed (the execution status of this line is deduced): context->ucharptr++;

2541 -

2542 #ifdef COMPILE_PCRE8 -

2543 if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1)) -

2544 #else -

2545

partially evaluated: context->ucharptr >= 2

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

partially evaluated: context->length == 0

TRUE	FALSE
yes Evaluation Count:9	no Evaluation Count:0

0-9

2546 #endif -

2547 { -

2548

if (context->length >= 4)

partially evaluated: context->length >= 4

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2549

OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);

never executed: sljit_emit_op1(compiler, (12), (context->sourcereg), (0), ((0x100 | (6))), (-context->length));

2550 #ifdef COMPILE_PCRE8 -

2551 else if (context->length >= 2) -

2552 OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2553 else if (context->length >= 1) -

2554 OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2555 #else -

2556

else if (context->length >= 2)

partially evaluated: context->length >= 2

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2557

OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);

never executed: sljit_emit_op1(compiler, (9), (context->sourcereg), (0), ((0x100 | (6))), (-context->length));

2558 #endif -

2559

context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;

partially evaluated: context->sourcereg == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2560 -

2561 switch(context->ucharptr) -

2562 { -

2563 case 4 / sizeof(pcre_uchar): -

2564

if (context->oc.asint != 0)

never evaluated: context->oc.asint != 0

2565

OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);

never executed: sljit_emit_op2(compiler, (29), (context->sourcereg), (0), (context->sourcereg), (0), (0x200), (context->oc.asint));

2566

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));

never executed (the execution status of this line is deduced):

 add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (context->sourcereg), (0), (0x200), (context->c.asint | context->oc.asint)));

2567

if (context->oc.asushort != 0)

never executed: break;

2568 -

2569 case 2 / sizeof(pcre_uchar): -

2570

partially evaluated: context->oc.asushort != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2571

OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);

never executed: sljit_emit_op2(compiler, (29), (context->sourcereg), (0), (context->sourcereg), (0), (0x200), (context->oc.asushort));

2572

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));

executed (the execution status of this line is deduced):

 add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (context->sourcereg), (0), (0x200), (context->c.asushort | context->oc.asushort)));

2573

executed: break;

Execution Count:9

2574 -

2575 #ifdef COMPILE_PCRE8 -

2576 case 1: -

2577 if (context->oc.asbyte != 0) -

2578 OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte); -

2579 add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte)); -

2580 break; -

2581 #endif -

2582 -

2583 default: -

2584

never executed: }

never evaluated: 0

2585

never executed: break;

2586 } -

2587

context->ucharptr = 0;

executed (the execution status of this line is deduced): context->ucharptr = 0;

2588

executed: }

Execution Count:9

2589 -

2590 #else -

2591 -

2592 /* Unaligned read is unsupported. */ -

2593 #ifdef COMPILE_PCRE8 -

2594 if (context->length > 0) -

2595 OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2596 #else -

2597 if (context->length > 0) -

2598 OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length); -

2599 #endif -

2600 context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1; -

2601 -

2602 if (othercasebit != 0 && othercasechar == cc) -

2603 { -

2604 OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit); -

2605 add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit)); -

2606 } -

2607 else -

2608 add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc)); -

2609 -

2610 #endif -

2611 -

2612

executed (the execution status of this line is deduced): cc++;

2613 #ifdef SUPPORT_UTF -

2614

utflength--;

executed (the execution status of this line is deduced): utflength--;

2615

executed: }

Execution Count:9

2616

while (utflength > 0);

partially evaluated: utflength > 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:9

0-9

2617 #endif -

2618 -

2619

executed: return cc;

Execution Count:9

2620 } -

2621 -

2622 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

2623 -

2624 #define SET_TYPE_OFFSET(value) \ -

2625 if ((value) != typeoffset) \ -

2626 { \ -

2627 if ((value) > typeoffset) \ -

2628 OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \ -

2629 else \ -

2630 OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \ -

2631 } \ -

2632 typeoffset = (value); -

2633 -

2634 #define SET_CHAR_OFFSET(value) \ -

2635 if ((value) != charoffset) \ -

2636 { \ -

2637 if ((value) > charoffset) \ -

2638 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (value) - charoffset); \ -

2639 else \ -

2640 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, charoffset - (value)); \ -

2641 } \ -

2642 charoffset = (value); -

2643 -

2644 static void compile_xclass_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks) -

2645 { -

2646

jump_list **list = (*cc & XCL_NOT) == 0 ? &found : fallbacks;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2647

jump_list *found = NULL;

executed (the execution status of this line is deduced): jump_list *found = ((void *)0);

2648

partially evaluated: (*cc & 0x01) == 0

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2649

unsigned int c;

executed (the execution status of this line is deduced): unsigned int c;

2650

int compares;

executed (the execution status of this line is deduced): int compares;

2651

executed (the execution status of this line is deduced): struct sljit_jump *jump = ((void *)0);

2652

BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;

executed (the execution status of this line is deduced): pcre_uchar *ccbegin;

2653 #ifdef SUPPORT_UCP -

2654

executed (the execution status of this line is deduced): BOOL needstype = 0, needsscript = 0, needschar = 0;

2655

BOOL charsaved = FALSE;

executed (the execution status of this line is deduced): BOOL charsaved = 0;

2656

int typereg = TMP1, scriptreg = TMP1;

executed (the execution status of this line is deduced): int typereg = 1, scriptreg = 1;

2657

unsigned int typeoffset;

executed (the execution status of this line is deduced): unsigned int typeoffset;

2658 #endif -

2659

int invertcmp, numberofcmps;

executed (the execution status of this line is deduced): int invertcmp, numberofcmps;

2660

unsigned int charoffset;

executed (the execution status of this line is deduced): unsigned int charoffset;

2661 -

2662 /* Although SUPPORT_UTF must be defined, we are not necessary in utf mode. */ -

2663

executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

2664

if ((*cc++ & XCL_MAP) != 0)

executed (the execution status of this line is deduced): read_char(common);

2665 -

2666

partially evaluated: (*cc++ & 0x02) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2667 { -

2668

OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), (1), (0));

2669 #ifndef COMPILE_PCRE8 -

2670

jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (4), (1), (0), (0x200), (255));

2671 #elif defined SUPPORT_UTF -

2672 if (common->utf) -

2673 jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255); -

2674 #endif -

2675 -

2676

OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (3), (0), (1), (0), (0x200), (0x7));

2677

OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (32), (1), (0), (1), (0), (0x200), (3));

2678

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (1))), ((sljit_w)cc));

2679

OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (0x200), (1), (3), (0));

2680

OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28 | 0x0200), (0), (0), (1), (0), (3), (0));

2681

add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, list, sljit_emit_jump(compiler, (1)));

2682 -

2683 #ifndef COMPILE_PCRE8 -

2684

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

2685 #elif defined SUPPORT_UTF -

2686 if (common->utf) -

2687 JUMPHERE(jump); -

2688 #endif -

2689

cc += 32 / sizeof(pcre_uchar);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (5), (0));

2690 #ifdef SUPPORT_UCP -

2691

charsaved = TRUE;

never executed (the execution status of this line is deduced): charsaved = 1;

2692 #endif -

2693

never executed (the execution status of this line is deduced): cc += 32 / sizeof(pcre_uchar);

2694

never executed: }

2695 -

2696 /* Scanning the necessary info. */ -

2697

executed (the execution status of this line is deduced): ccbegin = cc;

2698

compares = 0;

executed (the execution status of this line is deduced): compares = 0;

2699

while (*cc != XCL_END)

evaluated: *cc != 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:1

2700 { -

2701

compares++;

executed (the execution status of this line is deduced): compares++;

2702

if (*cc == XCL_SINGLE)

partially evaluated: *cc == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2703 { -

2704

if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

never executed (the execution status of this line is deduced): cc += 2;

2705 #ifdef SUPPORT_UTF -

2706

never executed: cc += 1;

never evaluated: common->utf

never evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

2707 #endif -

2708 #ifdef SUPPORT_UCP -

2709

needschar = TRUE;

never executed (the execution status of this line is deduced): needschar = 1;

2710 #endif -

2711

else if (*cc == XCL_RANGE)

never executed: }

2712

partially evaluated: *cc == 2

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2713 { -

2714

if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

executed (the execution status of this line is deduced): cc += 2;

2715 #ifdef SUPPORT_UTF -

2716

never executed: cc += 1;

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2717 #endif -

2718

if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

executed (the execution status of this line is deduced): cc++;

2719 #ifdef SUPPORT_UTF -

2720

never executed: cc += 1;

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: (((cc[-1]) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2721 #endif -

2722 #ifdef SUPPORT_UCP -

2723

needschar = TRUE;

executed (the execution status of this line is deduced): needschar = 1;

2724 #endif -

2725

SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);

executed: }

Execution Count:1

2726 #ifdef SUPPORT_UCP -

2727 else -

2728 { -

2729

never executed: }

never evaluated: 0

2730

never executed (the execution status of this line is deduced): cc++;

2731 switch(*cc) -

2732 { -

2733 case PT_ANY: -

2734

never executed: break;

2735 -

2736 case PT_LAMP: -

2737 case PT_GC: -

2738 case PT_PC: -

2739 case PT_ALNUM: -

2740

needstype = TRUE;

never executed (the execution status of this line is deduced): needstype = 1;

2741

never executed: break;

2742 -

2743 case PT_SC: -

2744

needsscript = TRUE;

never executed (the execution status of this line is deduced): needsscript = 1;

2745

never executed: break;

2746 -

2747 case PT_SPACE: -

2748 case PT_PXSPACE: -

2749 case PT_WORD: -

2750

needstype = TRUE;

never executed (the execution status of this line is deduced): needstype = 1;

2751

needschar = TRUE;

never executed (the execution status of this line is deduced): needschar = 1;

2752

never executed: break;

2753 -

2754 default: -

2755

never executed: }

never evaluated: 0

2756

never executed: break;

2757 } -

2758

never executed (the execution status of this line is deduced): cc += 2;

2759

if (needstype || needsscript)

never executed: }

2760 #endif -

2761 } -

2762 -

2763 #ifdef SUPPORT_UCP -

2764 /* Simple register allocation. TMP1 is preferred if possible. */ -

2765

partially evaluated: needstype

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

partially evaluated: needsscript

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2766 { -

2767

if (needschar && !charsaved)

never evaluated: needschar

never evaluated: !charsaved

2768

OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);

never executed: sljit_emit_op1(compiler, (6), (5), (0), (1), (0));

2769

add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->getucd, sljit_emit_jump(compiler, (23)));

2770

if (needschar)

never evaluated: needschar

2771 { -

2772

if (needstype)

never evaluated: needstype

2773 { -

2774

OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (4), (0), (1), (0));

2775

typereg = RETURN_ADDR;

never executed (the execution status of this line is deduced): typereg = 4;

2776

never executed: }

2777 -

2778

if (needsscript)

never evaluated: needsscript

2779

scriptreg = TMP3;

never executed: scriptreg = 5;

2780

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (5), (0));

2781

else if (needstype && needsscript)

never executed: }

2782

never evaluated: needstype

never evaluated: needsscript

2783

scriptreg = TMP3;

never executed: scriptreg = 5;

2784 /* In all other cases only one of them was specified, and that can goes to TMP1. */ -

2785 -

2786

if (needsscript)

never evaluated: needsscript

2787 { -

2788

if (scriptreg == TMP1)

never evaluated: scriptreg == 1

2789 { -

2790

OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), (scriptreg), (0), (0x200), ((sljit_w)_pcre16_ucd_records + ((sljit_w)(&((ucd_record*)0x10)->script) - 0x10)));

2791

OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM2(scriptreg, TMP2), 3);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (scriptreg), (0), ((0x100 | (scriptreg) | ((3) << 4))), (3));

2792

OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);

never executed: }

2793 else -

2794 { -

2795

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (3), (0), (0x200), (3));

2796

OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (23), (3), (0), (3), (0), (0x200), ((sljit_w)_pcre16_ucd_records + ((sljit_w)(&((ucd_record*)0x10)->script) - 0x10)));

2797

OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM1(TMP2), 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (scriptreg), (0), ((0x100 | (3))), (0));

2798

never executed: }

2799 } -

2800

never executed: }

2801 #endif -

2802 -

2803 /* Generating code. */ -

2804

cc = ccbegin;

executed (the execution status of this line is deduced): cc = ccbegin;

2805

charoffset = 0;

executed (the execution status of this line is deduced): charoffset = 0;

2806

invertcmp = (compares == 0 && list != fallbacks);

executed (the execution status of this line is deduced): numberofcmps = 0;

2807 #ifdef SUPPORT_UCP -

2808

typeoffset = 0;

executed (the execution status of this line is deduced): typeoffset = 0;

2809 #endif -

2810 -

2811

while (*cc != XCL_END)

evaluated: *cc != 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:1

2812 { -

2813

compares--;

executed (the execution status of this line is deduced): compares--;

2814

partially evaluated: compares == 0

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: list != fallbacks

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2815

jump = NULL;

executed (the execution status of this line is deduced): jump = ((void *)0);

2816 -

2817

if (*cc == XCL_SINGLE)

partially evaluated: *cc == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2818 { -

2819

cc ++;

never executed (the execution status of this line is deduced): cc ++;

2820 #ifdef SUPPORT_UTF -

2821

never evaluated: common->utf

2822 { -

2823

GETCHARINC(c, cc);

never executed: }

never evaluated: (c & 0xfc00) == 0xd800

2824

if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))

never executed: }

2825 else -

2826 #endif -

2827

c = *cc++;

never executed: c = *cc++;

2828 -

2829

never evaluated: numberofcmps < 3

never evaluated: *cc == 1

never evaluated: *cc == 2

2830 { -

2831

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (c - charoffset));

2832

COND_VALUE(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (numberofcmps == 0 ? 6 : 29), (3), (0), (0));

2833

numberofcmps++;

never executed (the execution status of this line is deduced): numberofcmps++;

2834

else if (numberofcmps > 0)

never executed: }

2835

never evaluated: numberofcmps > 0

2836 { -

2837

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (c - charoffset));

2838

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

2839

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (1 ^ invertcmp));

2840

never executed (the execution status of this line is deduced): numberofcmps = 0;

2841

jump = CMP(SLJIT_C_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);

never executed: }

2842 else -

2843 { -

2844

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0 ^ invertcmp), (1), (0), (0x200), (c - charoffset));

2845

never executed (the execution status of this line is deduced): numberofcmps = 0;

2846

else if (*cc == XCL_RANGE)

never executed: }

2847 } -

2848

partially evaluated: *cc == 2

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2849 { -

2850

cc ++;

executed (the execution status of this line is deduced): cc ++;

2851 #ifdef SUPPORT_UTF -

2852

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2853 { -

2854

GETCHARINC(c, cc);

never executed: }

partially evaluated: (c & 0xfc00) == 0xd800

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2855

executed: }

Execution Count:1

2856 else -

2857 #endif -

2858

c = *cc++;

never executed: c = *cc++;

2859

SET_CHAR_OFFSET(c);

never executed: sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), ((c) - charoffset));

never executed: sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (charoffset - (c)));

partially evaluated: (c) != charoffset

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

never evaluated: (c) > charoffset

0-1

2860 #ifdef SUPPORT_UTF -

2861

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2862 { -

2863

GETCHARINC(c, cc);

never executed: }

partially evaluated: (c & 0xfc00) == 0xd800

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2864

if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))

executed: }

Execution Count:1

2865 else -

2866 #endif -

2867

c = *cc++;

never executed: c = *cc++;

2868

partially evaluated: numberofcmps < 3

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: *cc == 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

partially evaluated: *cc == 2

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2869 { -

2870

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (c - charoffset));

2871

COND_VALUE(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (numberofcmps == 0 ? 6 : 29), (3), (0), (5));

2872

numberofcmps++;

never executed (the execution status of this line is deduced): numberofcmps++;

2873

else if (numberofcmps > 0)

never executed: }

2874

partially evaluated: numberofcmps > 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2875 { -

2876

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (c - charoffset));

2877

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (5));

2878

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (1 ^ invertcmp));

2879

never executed (the execution status of this line is deduced): numberofcmps = 0;

2880

jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);

never executed: }

2881 else -

2882 { -

2883

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (5 ^ invertcmp), (1), (0), (0x200), (c - charoffset));

2884

executed (the execution status of this line is deduced): numberofcmps = 0;

2885

executed: }

Execution Count:1

2886 } -

2887 #ifdef SUPPORT_UCP -

2888 else -

2889 { -

2890

if (*cc == XCL_NOTPROP)

never evaluated: *cc == 4

2891

invertcmp ^= 0x1;

never executed: invertcmp ^= 0x1;

2892

if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))

never executed (the execution status of this line is deduced): cc++;

2893 switch(*cc) -

2894 { -

2895 case PT_ANY: -

2896

if (list != fallbacks)

never evaluated: list != fallbacks

2897 { -

2898

never evaluated: cc[-1] == 4

never evaluated: compares > 0

never evaluated: cc[-1] == 3

never evaluated: compares == 0

2899

continue;

never executed: continue;

2900

else if (cc[-1] == XCL_NOTPROP)

never executed: }

2901

never evaluated: cc[-1] == 4

2902

continue;

never executed: continue;

2903

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (22));

2904

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);

never executed: break;

2905 -

2906 case PT_LAMP: -

2907

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (typereg), (0), (0x200), (ucp_Lu - typeoffset));

2908

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

2909

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (typereg), (0), (0x200), (ucp_Ll - typeoffset));

2910

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29), (3), (0), (0));

2911

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (typereg), (0), (0x200), (ucp_Lt - typeoffset));

2912

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

2913

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (1 ^ invertcmp));

2914

c = PRIV(ucp_typerange)[(int)cc[1] * 2];

never executed: break;

2915 -

2916 case PT_GC: -

2917

never executed (the execution status of this line is deduced): c = _pcre16_ucp_typerange[(int)cc[1] * 2];

2918

SET_TYPE_OFFSET(c);

never executed: sljit_emit_op2(compiler, (25), (typereg), (0), (typereg), (0), (0x200), ((c) - typeoffset));

never executed: sljit_emit_op2(compiler, (23), (typereg), (0), (typereg), (0), (0x200), (typeoffset - (c)));

never evaluated: (c) != typeoffset

never evaluated: (c) > typeoffset

2919

jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);

never executed (the execution status of this line is deduced):

 jump = sljit_emit_cmp(compiler, (5 ^ invertcmp), (typereg), (0), (0x200), (_pcre16_ucp_typerange[(int)cc[1] * 2 + 1] - c));

2920

jump = CMP(SLJIT_C_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);

never executed: break;

2921 -

2922 case PT_PC: -

2923

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0 ^ invertcmp), (typereg), (0), (0x200), ((int)cc[1] - typeoffset));

2924

jump = CMP(SLJIT_C_EQUAL ^ invertcmp, scriptreg, 0, SLJIT_IMM, (int)cc[1]);

never executed: break;

2925 -

2926 case PT_SC: -

2927

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0 ^ invertcmp), (scriptreg), (0), (0x200), ((int)cc[1]));

2928

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);

never executed: break;

2929 -

2930 case PT_SPACE: -

2931 case PT_PXSPACE: -

2932

if (*cc == PT_SPACE)

never evaluated: *cc == 6

2933 { -

2934

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (0));

2935

jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 11 - charoffset);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (11 - charoffset));

never executed: }

never executed: sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), ((9) - charoffset));

never executed: sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (charoffset - (9)));

never evaluated: (9) != charoffset

never evaluated: (9) > charoffset

2938

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 13 - 9);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (0x200), (13 - 9));

2939

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (5));

2940

if (*cc == PT_SPACE)

never evaluated: *cc == 6

2941

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);

never executed: sljit_set_label((jump), sljit_emit_label(compiler));

2942 -

2943

SET_TYPE_OFFSET(ucp_Zl);

never executed: sljit_emit_op2(compiler, (25), (typereg), (0), (typereg), (0), (0x200), ((ucp_Zl) - typeoffset));

never executed: sljit_emit_op2(compiler, (23), (typereg), (0), (typereg), (0), (0x200), (typeoffset - (ucp_Zl)));

never evaluated: (ucp_Zl) != typeoffset

never evaluated: (ucp_Zl) > typeoffset

2944

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (typereg), (0), (0x200), (ucp_Zs - ucp_Zl));

2945

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (5));

2946

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (1 ^ invertcmp));

2947

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);

never executed: break;

2948 -

2949 case PT_WORD: -

2950

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), ('\137' - charoffset));

2951

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

2952 /* ... fall through */ -

2953 -

2954

case PT_ALNUM:

code before this statement never executed: case 5:

2955

SET_TYPE_OFFSET(ucp_Ll);

never executed: sljit_emit_op2(compiler, (25), (typereg), (0), (typereg), (0), (0x200), ((ucp_Ll) - typeoffset));

never executed: sljit_emit_op2(compiler, (23), (typereg), (0), (typereg), (0), (0x200), (typeoffset - (ucp_Ll)));

never evaluated: (ucp_Ll) != typeoffset

never evaluated: (ucp_Ll) > typeoffset

2956

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (typereg), (0), (0x200), (ucp_Lu - ucp_Ll));

2957

COND_VALUE((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, ((*cc == 5) ? 6 : 29), (3), (0), (5));

2958

SET_TYPE_OFFSET(ucp_Nd);

never executed: sljit_emit_op2(compiler, (25), (typereg), (0), (typereg), (0), (0x200), ((ucp_Nd) - typeoffset));

never executed: sljit_emit_op2(compiler, (23), (typereg), (0), (typereg), (0), (0x200), (typeoffset - (ucp_Nd)));

never evaluated: (ucp_Nd) != typeoffset

never evaluated: (ucp_Nd) > typeoffset

2959

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (typereg), (0), (0x200), (ucp_No - ucp_Nd));

2960

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (5));

2961

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (1 ^ invertcmp));

2962

never executed: break;

2963 } -

2964

never executed (the execution status of this line is deduced): cc += 2;

2965

never executed: }

2966 #endif -

2967 -

2968

add_jump(compiler, compares > 0 ? list : fallbacks, jump);

partially evaluated: jump != ((void *)0)

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

2969

executed: add_jump(compiler, compares > 0 ? list : fallbacks, jump);

Execution Count:1

2970

set_jumps(found, LABEL());

executed: }

Execution Count:1

2971 -

2972

if (found != NULL)

partially evaluated: found != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

2973

never executed: set_jumps(found, sljit_emit_label(compiler));

2974

executed: }

Execution Count:1

2975 -

2976 #undef SET_TYPE_OFFSET -

2977 #undef SET_CHAR_OFFSET -

2978 -

2979 #endif -

2980 -

2981 static pcre_uchar *compile_char1_hotpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **fallbacks) -

2982 { -

2983

struct sljit_jump *jump[4];

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

2984

int length;

executed (the execution status of this line is deduced): int length;

2985

unsigned int c, oc, bit;

executed (the execution status of this line is deduced): unsigned int c, oc, bit;

2986

compare_context context;

executed (the execution status of this line is deduced): compare_context context;

2987

executed (the execution status of this line is deduced): struct sljit_jump *jump[4];

2988 #ifdef SUPPORT_UTF -

2989

executed (the execution status of this line is deduced): struct sljit_label *label;

2990 #ifdef SUPPORT_UCP -

2991

pcre_uchar propdata[5];

executed (the execution status of this line is deduced): pcre_uchar propdata[5];

2992 #endif -

2993 #endif -

2994 -

2995 switch(type) -

2996 { -

2997 case OP_SOD: -

2998

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

2999

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

3000

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (6), (0), (1), (0)));

3001

never executed: return cc;

3002 -

3003 case OP_SOM: -

3004

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

3005

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->str) - 0x10)));

3006

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (6), (0), (1), (0)));

3007

add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));

never executed: return cc;

3008 -

3009 case OP_NOT_WORD_BOUNDARY: -

3010 case OP_WORD_BOUNDARY: -

3011

executed (the execution status of this line is deduced): add_jump(compiler, &common->wordboundary, sljit_emit_jump(compiler, (23)));

3012

add_jump(compiler, fallbacks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (type == OP_NOT_WORD_BOUNDARY ? 1 : 0)));

3013

executed: return cc;

Execution Count:1

3014 -

3015 case OP_NOT_DIGIT: -

3016 case OP_DIGIT: -

3017

OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3018

read_char8_type(common);

never executed (the execution status of this line is deduced): read_char8_type(common);

3019

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28 | 0x0200), (0), (0), (1), (0), (0x200), (0x04));

3020

add_jump(compiler, fallbacks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (type == OP_DIGIT ? 0 : 1)));

3021

never executed: return cc;

3022 -

3023 case OP_NOT_WHITESPACE: -

3024 case OP_WHITESPACE: -

3025

OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3026

read_char8_type(common);

never executed (the execution status of this line is deduced): read_char8_type(common);

3027

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28 | 0x0200), (0), (0), (1), (0), (0x200), (0x01));

3028

add_jump(compiler, fallbacks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (type == OP_WHITESPACE ? 0 : 1)));

3029

never executed: return cc;

3030 -

3031 case OP_NOT_WORDCHAR: -

3032 case OP_WORDCHAR: -

3033

OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3034

read_char8_type(common);

never executed (the execution status of this line is deduced): read_char8_type(common);

3035

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28 | 0x0200), (0), (0), (1), (0), (0x200), (0x10));

3036

add_jump(compiler, fallbacks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (type == OP_WORDCHAR ? 0 : 1)));

3037

never executed: return cc;

3038 -

3039 case OP_ANY: -

3040

executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3041

if (common->nltype == NLTYPE_FIXED && common->newline > 255)

executed (the execution status of this line is deduced): read_char(common);

3042

evaluated: common->nltype == 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:1

evaluated: common->newline > 255

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:2

1-4

3043 { -

3044

jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);

executed (the execution status of this line is deduced): jump[0] = sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ((common->newline >> 8) & 0xff));

3045

jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

executed (the execution status of this line is deduced): jump[1] = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

3046

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

3047

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (common->newline & 0xff)));

3048

executed (the execution status of this line is deduced): sljit_set_label((jump[1]), sljit_emit_label(compiler));

3049

executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3050

check_newlinechar(common, common->nltype, fallbacks, TRUE);

executed: }

Execution Count:2

3051 else -

3052

executed: check_newlinechar(common, common->nltype, fallbacks, 1);

Execution Count:3

3053

executed: return cc;

Execution Count:5

3054 -

3055 case OP_ALLANY: -

3056

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3057 #ifdef SUPPORT_UTF -

3058

never evaluated: common->utf

3059 { -

3060

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

3061

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

3062 #ifdef COMPILE_PCRE8 -

3063 jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0); -

3064 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0); -

3065 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); -

3066 #else /* COMPILE_PCRE8 */ -

3067 #ifdef COMPILE_PCRE16 -

3068

jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (0xd800));

3069

OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (1), (0), (1), (0), (0x200), (0xfc00));

3070

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (0xd800));

3071

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (1), (0), (0));

3072

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (1), (0), (1), (0), (0x200), (1));

3073

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (1), (0));

3074 #endif /* COMPILE_PCRE16 */ -

3075 #endif /* COMPILE_PCRE8 */ -

3076

never executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3077

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed: return cc;

3078 } -

3079 #endif -

3080

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

3081

never executed: return cc;

3082 -

3083 case OP_ANYBYTE: -

3084

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3085

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

3086

propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;

never executed: return cc;

3087 -

3088 #ifdef SUPPORT_UTF -

3089 #ifdef SUPPORT_UCP -

3090 case OP_NOTPROP: -

3091 case OP_PROP: -

3092

propdata[0] = 0;

never executed (the execution status of this line is deduced): propdata[0] = 0;

3093

never evaluated: type == OP_NOTPROP

3094

propdata[2] = cc[0];

never executed (the execution status of this line is deduced): propdata[2] = cc[0];

3095

propdata[3] = cc[1];

never executed (the execution status of this line is deduced): propdata[3] = cc[1];

3096

propdata[4] = XCL_END;

never executed (the execution status of this line is deduced): propdata[4] = 0;

3097

compile_xclass_hotpath(common, propdata, fallbacks);

never executed (the execution status of this line is deduced): compile_xclass_hotpath(common, propdata, fallbacks);

3098

return cc + 2;

never executed: return cc + 2;

3099 #endif -

3100 #endif -

3101 -

3102 case OP_ANYNL: -

3103

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3104

jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);

never executed (the execution status of this line is deduced): read_char(common);

3105

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ('\015'));

3106

jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed (the execution status of this line is deduced): jump[1] = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

3107

jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (0));

3108

never executed (the execution status of this line is deduced): jump[2] = sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ('\012'));

3109

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((1) << 1)));

3110

jump[3] = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): jump[3] = sljit_emit_jump(compiler, (22));

3111

check_newlinechar(common, common->bsr_nltype, fallbacks, FALSE);

never executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3112

never executed (the execution status of this line is deduced): check_newlinechar(common, common->bsr_nltype, fallbacks, 0);

3113

never executed (the execution status of this line is deduced): sljit_set_label((jump[1]), sljit_emit_label(compiler));

3114

JUMPHERE(jump[2]);

never executed (the execution status of this line is deduced): sljit_set_label((jump[2]), sljit_emit_label(compiler));

3115

JUMPHERE(jump[3]);

never executed (the execution status of this line is deduced): sljit_set_label((jump[3]), sljit_emit_label(compiler));

3116

never executed: return cc;

3117 -

3118 case OP_NOT_HSPACE: -

3119 case OP_HSPACE: -

3120

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3121

add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): read_char(common);

3122

never executed (the execution status of this line is deduced): add_jump(compiler, &common->hspace, sljit_emit_jump(compiler, (23)));

3123

add_jump(compiler, fallbacks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (type == OP_NOT_HSPACE ? 1 : 0)));

3124

never executed: return cc;

3125 -

3126 case OP_NOT_VSPACE: -

3127 case OP_VSPACE: -

3128

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3129

add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): read_char(common);

3130

never executed (the execution status of this line is deduced): add_jump(compiler, &common->vspace, sljit_emit_jump(compiler, (23)));

3131

add_jump(compiler, fallbacks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (type == OP_NOT_VSPACE ? 1 : 0)));

3132

never executed: return cc;

3133 -

3134 #ifdef SUPPORT_UCP -

3135 case OP_EXTUNI: -

3136

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3137

add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): read_char(common);

3138

never executed (the execution status of this line is deduced): add_jump(compiler, &common->getucd, sljit_emit_jump(compiler, (23)));

3139

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (ucp_Mc));

3140

add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (5), (1), (0), (0x200), (ucp_Mn - ucp_Mc)));

3141 -

3142

jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

3143

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

3144

OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), (6), (0));

3145

add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): read_char(common);

3146

never executed (the execution status of this line is deduced): add_jump(compiler, &common->getucd, sljit_emit_jump(compiler, (23)));

3147

OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (1), (0), (1), (0), (0x200), (ucp_Mc));

3148

CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (5), (1), (0), (0x200), (ucp_Mn - ucp_Mc)), (label));

3149 -

3150

OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), (5), (0));

3151

never executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3152

jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);

never executed: return cc;

3153 #endif -

3154 -

3155 case OP_EODN: -

3156

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_cmp(compiler, (3), (6), (0), (7), (0));

3157

if (common->nltype == NLTYPE_FIXED && common->newline > 255)

never evaluated: common->nltype == 0

never evaluated: common->newline > 255

3158 { -

3159

OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (3), (0), (6), (0), (0x200), (((2) << 1)));

3160

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((0) << 1)));

3161

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (7), (0)));

3162

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (((1) << 1)));

3163

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ((common->newline >> 8) & 0xff)));

3164

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (common->newline & 0xff)));

3165

else if (common->nltype == NLTYPE_FIXED)

never executed: }

3166

never evaluated: common->nltype == 0

3167 { -

3168

OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (3), (0), (6), (0), (0x200), (((1) << 1)));

3169

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((0) << 1)));

3170

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (7), (0)));

3171

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (1), (0), (0x200), (common->newline)));

3172

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));

never executed: }

3173 else -

3174 { -

3175

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((0) << 1)));

3176

jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);

never executed (the execution status of this line is deduced): jump[1] = sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ('\015'));

3177

OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (3), (0), (6), (0), (0x200), (((2) << 1)));

3178

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (3), (0), (7), (0));

3179

jump[2] = JUMP(SLJIT_C_GREATER);

never executed (the execution status of this line is deduced): jump[2] = sljit_emit_jump(compiler, (4));

3180

add_jump(compiler, fallbacks, JUMP(SLJIT_C_LESS));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (2)));

3181 /* Equal. */ -

3182

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((1) << 1)));

3183

jump[3] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);

never executed (the execution status of this line is deduced): jump[3] = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), ('\012'));

3184

add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (22)));

3185 -

3186

if (common->nltype == NLTYPE_ANYCRLF)

never executed (the execution status of this line is deduced): sljit_set_label((jump[1]), sljit_emit_label(compiler));

3187

never evaluated: common->nltype == 2

3188 { -

3189

OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (3), (0), (6), (0), (0x200), (((1) << 1)));

3190

add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (2), (3), (0), (7), (0)));

3191

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ('\012')));

3192

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);

never executed: }

3193 else -

3194 { -

3195

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (6), (0));

3196

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));

never executed (the execution status of this line is deduced): read_char(common);

3197

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (6), (0), (7), (0)));

3198

add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->anynewline, sljit_emit_jump(compiler, (23)));

3199

add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (0)));

3200

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), ((1 * sizeof(sljit_w))));

never executed: }

never executed (the execution status of this line is deduced): sljit_set_label((jump[2]), sljit_emit_label(compiler));

3203

JUMPHERE(jump[3]);

never executed (the execution status of this line is deduced): sljit_set_label((jump[3]), sljit_emit_label(compiler));

never executed: }

never executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3206

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));

never executed: return cc;

3207 -

3208 case OP_EOD: -

3209

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (6), (0), (7), (0)));

3210

never executed: return cc;

3211 -

3212 case OP_CIRC: -

3213

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (9), (0));

3214

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (3))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

3215

add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (4), (6), (0), (1), (0)));

3216

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (3))), (((sljit_w)(&((jit_arguments*)0x10)->notbol) - 0x10)));

3217

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)));

3218

never executed: return cc;

3219 -

3220 case OP_CIRCM: -

3221

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (9), (0));

3222

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (3))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

3223

jump[1] = CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0);

never executed (the execution status of this line is deduced): jump[1] = sljit_emit_cmp(compiler, (4), (6), (0), (1), (0));

3224

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (3))), (((sljit_w)(&((jit_arguments*)0x10)->notbol) - 0x10)));

3225

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)));

3226

jump[0] = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_jump(compiler, (22));

3227

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, STR_PTR, 0, STR_END, 0));

never executed (the execution status of this line is deduced): sljit_set_label((jump[1]), sljit_emit_label(compiler));

3228 -

3229

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (6), (0), (7), (0)));

3230

if (common->nltype == NLTYPE_FIXED && common->newline > 255)

never evaluated: common->nltype == 0

never evaluated: common->newline > 255

3231 { -

3232

OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (3), (0), (6), (0), (0x200), (((2) << 1)));

3233

add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (2), (3), (0), (1), (0)));

3234

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((-2) << 1)));

3235

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (((-1) << 1)));

3236

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ((common->newline >> 8) & 0xff)));

3237

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (common->newline & 0xff)));

3238

never executed: }

3239 else -

3240 { -

3241

never executed (the execution status of this line is deduced): skip_char_back(common);

3242

check_newlinechar(common, common->nltype, fallbacks, FALSE);

never executed (the execution status of this line is deduced): read_char(common);

3243

never executed (the execution status of this line is deduced): check_newlinechar(common, common->nltype, fallbacks, 0);

never executed: }

never executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3246

never executed: return cc;

3247 -

3248 case OP_DOLL: -

3249

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (9), (0));

3250

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (3))), (((sljit_w)(&((jit_arguments*)0x10)->noteol) - 0x10)));

3251

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)));

3252 -

3253

if (!common->endonly)

never evaluated: !common->endonly

3254

compile_char1_hotpath(common, OP_EODN, cc, fallbacks);

never executed: compile_char1_hotpath(common, OP_EODN, cc, fallbacks);

3255 else -

3256

add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));

never executed: add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (2), (6), (0), (7), (0)));

3257

jump[1] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);

never executed: return cc;

3258 -

3259 case OP_DOLLM: -

3260

never executed (the execution status of this line is deduced): jump[1] = sljit_emit_cmp(compiler, (2), (6), (0), (7), (0));

3261

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (9), (0));

3262

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (3))), (((sljit_w)(&((jit_arguments*)0x10)->noteol) - 0x10)));

3263

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)));

3264

jump[0] = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_jump(compiler, (22));

3265

if (common->nltype == NLTYPE_FIXED && common->newline > 255)

never executed (the execution status of this line is deduced): sljit_set_label((jump[1]), sljit_emit_label(compiler));

3266 -

3267

never evaluated: common->nltype == 0

never evaluated: common->newline > 255

3268 { -

3269

OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (3), (0), (6), (0), (0x200), (((2) << 1)));

3270

add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (4), (3), (0), (7), (0)));

3271

OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (1), (0), ((0x100 | (6))), (((0) << 1)));

3272

OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (9), (3), (0), ((0x100 | (6))), (((1) << 1)));

3273

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (1), (0), (0x200), ((common->newline >> 8) & 0xff)));

3274

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (common->newline & 0xff)));

3275

check_newlinechar(common, common->nltype, fallbacks, FALSE);

never executed: }

3276 else -

3277 { -

3278

peek_char(common);

never executed (the execution status of this line is deduced): peek_char(common);

3279

never executed (the execution status of this line is deduced): check_newlinechar(common, common->nltype, fallbacks, 0);

never executed: }

never executed (the execution status of this line is deduced): sljit_set_label((jump[0]), sljit_emit_label(compiler));

3282

if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);

never executed: return cc;

3283 -

3284 case OP_CHAR: -

3285 case OP_CHARI: -

3286

length = 1;

executed (the execution status of this line is deduced): length = 1;

3287 #ifdef SUPPORT_UTF -

3288

never executed: length += 1;

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

partially evaluated: (((*cc) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

3289 #endif -

3290

if (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0)

partially evaluated: type == OP_CHAR

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

never evaluated: !char_has_othercase(common, cc)

never evaluated: char_get_othercase_bit(common, cc) != 0

0-2

3291 { -

3292

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (((length) << 1)));

3293

add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (4), (6), (0), (7), (0)));

3294 -

3295

context.length = IN_UCHARS(length);

executed (the execution status of this line is deduced): context.length = ((length) << 1);

3296

context.sourcereg = -1;

executed (the execution status of this line is deduced): context.sourcereg = -1;

3297 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED -

3298

context.ucharptr = 0;

executed (the execution status of this line is deduced): context.ucharptr = 0;

3299 #endif -

3300

return byte_sequence_compare(common, type == OP_CHARI, cc, &context, fallbacks);

executed: return byte_sequence_compare(common, type == OP_CHARI, cc, &context, fallbacks);

Execution Count:2

3301 } -

3302

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3303

never executed (the execution status of this line is deduced): read_char(common);

3304 #ifdef SUPPORT_UTF -

3305

never evaluated: common->utf

3306 { -

3307

GETCHAR(c, cc);

never executed: }

never evaluated: (c & 0xfc00) == 0xd800

3308

never executed: }

3309 else -

3310 #endif -

3311

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);

never executed: c = *cc;

3312

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (c));

3313

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char_othercase(common, c));

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

3314

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), (0x200), (char_othercase(common, c)));

3315

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

3316

add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (0)));

3317

return cc + length;

never executed: return cc + length;

3318 -

3319 case OP_NOT: -

3320 case OP_NOTI: -

3321

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3322

length = 1;

never executed (the execution status of this line is deduced): length = 1;

3323 #ifdef SUPPORT_UTF -

3324

GETCHARLEN(c, cc, length);

never evaluated: common->utf

3325 { -

3326 #ifdef COMPILE_PCRE8 -

3327 c = *cc; -

3328 if (c < 128) -

3329 { -

3330 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0); -

3331 if (type == OP_NOT || !char_has_othercase(common, cc)) -

3332 add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c)); -

3333 else -

3334 { -

3335 /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */ -

3336 OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20); -

3337 add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20)); -

3338 } -

3339 /* Skip the variable-length character. */ -

3340 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1)); -

3341 jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0); -

3342 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0); -

3343 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0); -

3344 JUMPHERE(jump[0]); -

3345 return cc + 1; -

3346 } -

3347 else -

3348 #endif /* COMPILE_PCRE8 */ -

3349 { -

3350

never executed: }

never evaluated: (c & 0xfc00) == 0xd800

3351

never executed (the execution status of this line is deduced): read_char(common);

3352 } -

3353

never executed: }

3354 else -

3355 #endif /* SUPPORT_UTF */ -

3356 { -

3357

never executed (the execution status of this line is deduced): read_char(common);

3358

never executed (the execution status of this line is deduced): c = *cc;

3359

if (type == OP_NOT || !char_has_othercase(common, cc))

never executed: }

3360 -

3361

never evaluated: type == OP_NOT

never evaluated: !char_has_othercase(common, cc)

3362

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));

never executed: add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (c)));

3363 else -

3364 { -

3365

oc = char_othercase(common, c);

never executed (the execution status of this line is deduced): oc = char_othercase(common, c);

3366

bit = c ^ oc;

never executed (the execution status of this line is deduced): bit = c ^ oc;

3367

if (ispowerof2(bit))

never evaluated: ispowerof2(bit)

3368 { -

3369

OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (29), (1), (0), (1), (0), (0x200), (bit));

3370

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (c | bit)));

3371

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));

never executed: }

3372 else -

3373 { -

3374

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (c)));

3375

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (oc)));

3376

never executed: }

3377 } -

3378

never executed: return cc + 1;

3379 -

3380 case OP_CLASS: -

3381 case OP_NCLASS: -

3382

never executed (the execution status of this line is deduced): check_input_end(common, fallbacks);

3383

jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);

never executed (the execution status of this line is deduced): read_char(common);

3384 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

3385

jump[0] = NULL;

never executed (the execution status of this line is deduced): jump[0] = ((void *)0);

3386 #ifdef COMPILE_PCRE8 -

3387 /* This check only affects 8 bit mode. In other modes, we -

3388 always need to compare the value with 255. */ -

3389 if (common->utf) -

3390 #endif /* COMPILE_PCRE8 */ -

3391 { -

3392

never executed (the execution status of this line is deduced): jump[0] = sljit_emit_cmp(compiler, (4), (1), (0), (0x200), (255));

3393

if (type == OP_CLASS)

never evaluated: type == OP_CLASS

3394 { -

3395

add_jump(compiler, fallbacks, jump[0]);

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, jump[0]);

3396

jump[0] = NULL;

never executed (the execution status of this line is deduced): jump[0] = ((void *)0);

3397

OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);

never executed: }

3398 } -

3399 #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */ -

3400

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28), (3), (0), (1), (0), (0x200), (0x7));

3401

OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (32), (1), (0), (1), (0), (0x200), (3));

3402

OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (1), (0), ((0x100 | (1))), ((sljit_w)cc));

3403

OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (31), (3), (0), (0x200), (1), (3), (0));

3404

OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (28 | 0x0200), (0), (0), (1), (0), (3), (0));

3405

add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_jump(compiler, (0)));

3406 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

3407

if (jump[0] != NULL)

never evaluated: jump[0] != ((void *)0)

3408

return cc + 32 / sizeof(pcre_uchar);

never executed: sljit_set_label((jump[0]), sljit_emit_label(compiler));

3409 #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */ -

3410

never executed: return cc + 32 / sizeof(pcre_uchar);

3411 -

3412 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

3413 case OP_XCLASS: -

3414

compile_xclass_hotpath(common, cc + LINK_SIZE, fallbacks);

executed (the execution status of this line is deduced): compile_xclass_hotpath(common, cc + 1, fallbacks);

3415

return cc + GET(cc, 0) - 1;

executed: return cc + (cc[0]) - 1;

Execution Count:1

3416 #endif -

3417 -

3418 case OP_REVERSE: -

3419

length = GET(cc, 0);

never executed (the execution status of this line is deduced): length = (cc[0]);

3420

SLJIT_ASSERT(length > 0);

never executed: }

never evaluated: 0

3421

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

3422 #ifdef SUPPORT_UTF -

3423

OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));

never evaluated: common->utf

3424 { -

3425

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

3426

OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (length));

3427

add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

3428

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (5), (6), (0), (5), (0)));

3429

OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): skip_char_back(common);

3430

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0200), (3), (0), (3), (0), (0x200), (1));

3431

JUMPTO(SLJIT_C_NOT_ZERO, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (1)), (label));

3432

return cc + LINK_SIZE;

never executed: return cc + 1;

3433 } -

3434 #endif -

3435

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->begin) - 0x10)));

3436

OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (6), (0), (6), (0), (0x200), (((length) << 1)));

3437

add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (2), (6), (0), (1), (0)));

3438

return cc + LINK_SIZE;

never executed: return cc + 1;

3439 } -

3440

never executed: }

never evaluated: 0

3441

never executed: return cc;

3442 } -

3443 -

3444 static SLJIT_INLINE pcre_uchar *compile_charn_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **fallbacks) -

3445 { -

3446 /* This function consumes at least one input character. */ -

3447 /* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */ -

3448

pcre_uchar *ccbegin = cc;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

3449

executed (the execution status of this line is deduced): pcre_uchar *ccbegin = cc;

3450

compare_context context;

executed (the execution status of this line is deduced): compare_context context;

3451

int size;

executed (the execution status of this line is deduced): int size;

3452 -

3453

context.length = 0;

executed (the execution status of this line is deduced): context.length = 0;

3454 do -

3455 { -

3456

if (cc >= ccend)

evaluated: cc >= ccend

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:7

3457

if (common->utf && HAS_EXTRALEN(cc[1]))

executed: break;

Execution Count:7

3458 -

3459

if (*cc == OP_CHAR)

partially evaluated: *cc == OP_CHAR

TRUE	FALSE
yes Evaluation Count:7	no Evaluation Count:0

0-7

3460 { -

3461

size = 1;

executed (the execution status of this line is deduced): size = 1;

3462 #ifdef SUPPORT_UTF -

3463

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:7	no Evaluation Count:0

partially evaluated: (((cc[1]) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:7

0-7

3464

size += GET_EXTRALEN(cc[1]);

never executed: size += 1;

3465 #endif -

3466

else if (*cc == OP_CHARI)

executed: }

Execution Count:7

3467

never evaluated: *cc == OP_CHARI

3468 { -

3469

size = 1;

never executed (the execution status of this line is deduced): size = 1;

3470 #ifdef SUPPORT_UTF -

3471

if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)

never evaluated: common->utf

3472 { -

3473

never evaluated: char_has_othercase(common, cc + 1)

never evaluated: char_get_othercase_bit(common, cc + 1) == 0

3474

size = 0;

never executed: size = 0;

3475

else if (HAS_EXTRALEN(cc[1]))

never evaluated: (((cc[1]) & 0xfc00) == 0xd800)

3476

size += GET_EXTRALEN(cc[1]);

never executed: size += 1;

3477 } -

3478 else -

3479 #endif -

3480

if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)

never evaluated: char_has_othercase(common, cc + 1)

never evaluated: char_get_othercase_bit(common, cc + 1) == 0

3481

size = 0;

never executed: size = 0;

3482 } -

3483 else -

3484

size = 0;

never executed: size = 0;

3485 -

3486

cc += 1 + size;

executed (the execution status of this line is deduced): cc += 1 + size;

3487

context.length += IN_UCHARS(size);

executed (the execution status of this line is deduced): context.length += ((size) << 1);

3488

while (size > 0 && context.length <= 128);

executed: }

Execution Count:7

3489

partially evaluated: size > 0

TRUE	FALSE
yes Evaluation Count:7	no Evaluation Count:0

partially evaluated: context.length <= 128

TRUE	FALSE
yes Evaluation Count:7	no Evaluation Count:0

0-7

3490 -

3491

cc = ccbegin;

executed (the execution status of this line is deduced): cc = ccbegin;

3492

if (context.length > 0)

partially evaluated: context.length > 0

TRUE	FALSE
yes Evaluation Count:7	no Evaluation Count:0

0-7

3493 { -

3494 /* We have a fixed-length byte sequence. */ -

3495

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);

executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (0x200), (context.length));

3496

add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));

executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (4), (6), (0), (7), (0)));

3497 -

3498

context.sourcereg = -1;

executed (the execution status of this line is deduced): context.sourcereg = -1;

3499 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED -

3500

context.ucharptr = 0;

executed (the execution status of this line is deduced): context.ucharptr = 0;

3501 #endif -

3502

do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, fallbacks); while (context.length > 0);

executed: cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, fallbacks);

Execution Count:7

partially evaluated: context.length > 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:7

0-7

3503

return compile_char1_hotpath(common, *cc, cc + 1, fallbacks);

executed: return cc;

Execution Count:7

3504 } -

3505 -

3506 /* A non-fixed length character will be checked if length == 0. */ -

3507

never executed: return compile_char1_hotpath(common, *cc, cc + 1, fallbacks);

3508 } -

3509 -

3510 static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks) -

3511 { -

3512

int offset = GET2(cc, 1) << 1;

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

3513

never executed (the execution status of this line is deduced): int offset = cc[1] << 1;

3514 -

3515

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))));

3516

if (!common->jscript_compat)

never evaluated: !common->jscript_compat

3517 { -

3518

if (fallbacks == NULL)

never evaluated: fallbacks == ((void *)0)

3519 { -

3520

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w))));

3521

OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (0));

3522

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (25 | 0x0200), (0), (0), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))));

3523

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (0));

3524

return JUMP(SLJIT_C_NOT_ZERO);

never executed: return sljit_emit_jump(compiler, (1));

3525 } -

3526

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));

never executed (the execution status of this line is deduced):

 add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w)))));

3527

return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));

never executed: }

3528

never executed:

return sljit_emit_cmp(compiler, (0), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))));

3529 } -

3530 -

3531 /* Forward definitions. */ -

3532 static void compile_hotpath(compiler_common *, pcre_uchar *, pcre_uchar *, fallback_common *); -

3533 static void compile_fallbackpath(compiler_common *, struct fallback_common *); -

3534 -

3535 #define PUSH_FALLBACK(size, ccstart, error) \ -

3536 do \ -

3537 { \ -

3538 fallback = sljit_alloc_memory(compiler, (size)); \ -

3539 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \ -

3540 return error; \ -

3541 memset(fallback, 0, size); \ -

3542 fallback->prev = parent->top; \ -

3543 fallback->cc = (ccstart); \ -

3544 parent->top = fallback; \ -

3545 } \ -

3546 while (0) -

3547 -

3548 #define PUSH_FALLBACK_NOVALUE(size, ccstart) \ -

3549 do \ -

3550 { \ -

3551 fallback = sljit_alloc_memory(compiler, (size)); \ -

3552 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \ -

3553 return; \ -

3554 memset(fallback, 0, size); \ -

3555 fallback->prev = parent->top; \ -

3556 fallback->cc = (ccstart); \ -

3557 parent->top = fallback; \ -

3558 } \ -

3559 while (0) -

3560 -

3561 #define FALLBACK_AS(type) ((type*)fallback) -

3562 -

3563 static pcre_uchar *compile_ref_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks, BOOL withchecks, BOOL emptyfail) -

3564 { -

3565

int offset = GET2(cc, 1) << 1;

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

3566

never executed (the execution status of this line is deduced): int offset = cc[1] << 1;

3567

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));

never executed (the execution status of this line is deduced): struct sljit_jump *jump = ((void *)0);

3568 -

3569

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))));

3570

if (withchecks && !common->jscript_compat)

never evaluated: withchecks

never evaluated: !common->jscript_compat

3571

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));

never executed:

add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w)))));

3572 -

3573 #if defined SUPPORT_UTF && defined SUPPORT_UCP -

3574

if (common->utf && *cc == OP_REFI)

never evaluated: common->utf

never evaluated: *cc == OP_REFI

3575 { -

3576

SLJIT_ASSERT(TMP1 == SLJIT_TEMPORARY_REG1 && STACK_TOP == SLJIT_TEMPORARY_REG2 && TMP2 == SLJIT_TEMPORARY_REG3);

never executed: }

never evaluated: 0

3577

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))));

3578

if (withchecks)

never evaluated: withchecks

3579

jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);

never executed: jump = sljit_emit_cmp(compiler, (0), (1), (0), (3), (0));

3580 -

3581 /* Needed to save important temporary registers. */ -

3582

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((0 * sizeof(sljit_w))), (2), (0));

3583

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), (9), (0));

3584

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, ptr), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((sljit_w)(&((jit_arguments*)0x10)->ptr) - 0x10)), (6), (0));

3585

sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));

never executed (the execution status of this line is deduced): sljit_emit_ijump(compiler, 27, 0x200, ((sljit_w)do_utf_caselesscmp));

3586

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), ((0 * sizeof(sljit_w))));

3587

add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (0)));

3588

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), (1), (0));

3589

OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);

never executed: }

3590 else -

3591 #endif /* SUPPORT_UTF && SUPPORT_UCP */ -

3592 { -

3593

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (25 | 0x0200), (3), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (1), (0));

3594

if (withchecks)

never evaluated: withchecks

3595

jump = JUMP(SLJIT_C_ZERO);

never executed: jump = sljit_emit_jump(compiler, (0));

3596

OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (6), (0), (6), (0), (3), (0));

3597 -

3598

add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (4), (6), (0), (7), (0)));

3599

add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, sljit_emit_jump(compiler, (23)));

3600

add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, fallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)));

3601

never executed: }

3602 -

3603

add_jump(compiler, fallbacks, jump);

never evaluated: jump != ((void *)0)

3604 { -

3605

if (emptyfail)

never evaluated: emptyfail

3606

never executed: add_jump(compiler, fallbacks, jump);

3607 else -

3608

return cc + 1 + IMM2_SIZE;

never executed: sljit_set_label((jump), sljit_emit_label(compiler));

3609 } -

3610

never executed: return cc + 1 + 1;

3611 } -

3612 -

3613 static SLJIT_INLINE pcre_uchar *compile_ref_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent) -

3614 { -

3615

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

3616

never executed (the execution status of this line is deduced): fallback_common *fallback;

3617

never executed (the execution status of this line is deduced): pcre_uchar type;

3618

struct sljit_jump *zerolength;

never executed (the execution status of this line is deduced): struct sljit_label *label;

3619

never executed (the execution status of this line is deduced): struct sljit_jump *zerolength;

3620

pcre_uchar *ccbegin = cc;

never executed (the execution status of this line is deduced): struct sljit_jump *jump = ((void *)0);

3621

never executed (the execution status of this line is deduced): pcre_uchar *ccbegin = cc;

3622

int min = 0, max = 0;

never executed (the execution status of this line is deduced): int min = 0, max = 0;

3623

BOOL minimize;

never executed (the execution status of this line is deduced): BOOL minimize;

3624 -

3625

PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);

never executed: return ((void *)0);

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

3626 -

3627

type = cc[1 + IMM2_SIZE];

never executed (the execution status of this line is deduced): type = cc[1 + 1];

3628

minimize = (type & 0x1) != 0;

never executed (the execution status of this line is deduced): minimize = (type & 0x1) != 0;

3629 switch(type) -

3630 { -

3631 case OP_CRSTAR: -

3632 case OP_CRMINSTAR: -

3633

min = 0;

never executed (the execution status of this line is deduced): min = 0;

3634

max = 0;

never executed (the execution status of this line is deduced): max = 0;

3635

cc += 1 + IMM2_SIZE + 1;

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

3636

never executed: break;

3637 case OP_CRPLUS: -

3638 case OP_CRMINPLUS: -

3639

min = 1;

never executed (the execution status of this line is deduced): min = 1;

3640

max = 0;

never executed (the execution status of this line is deduced): max = 0;

3641

cc += 1 + IMM2_SIZE + 1;

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

3642

never executed: break;

3643 case OP_CRQUERY: -

3644 case OP_CRMINQUERY: -

3645

min = 0;

never executed (the execution status of this line is deduced): min = 0;

3646

max = 1;

never executed (the execution status of this line is deduced): max = 1;

3647

cc += 1 + IMM2_SIZE + 1;

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1;

3648

min = GET2(cc, 1 + IMM2_SIZE + 1);

never executed: break;

3649 case OP_CRRANGE: -

3650 case OP_CRMINRANGE: -

3651

never executed (the execution status of this line is deduced): min = cc[1 + 1 + 1];

3652

max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);

never executed (the execution status of this line is deduced): max = cc[1 + 1 + 1 + 1];

3653

cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;

never executed (the execution status of this line is deduced): cc += 1 + 1 + 1 + 2 * 1;

3654

never executed: break;

3655 default: -

3656

never executed: }

never evaluated: 0

3657

never executed: break;

3658 } -

3659 -

3660

if (!minimize)

never evaluated: !minimize

3661 { -

3662

if (min == 0)

never evaluated: min == 0

3663 { -

3664

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 2);

3665

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3666

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3667 /* Temporary release of STR_PTR. */ -

3668

OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

3669

zerolength = compile_ref_checks(common, ccbegin, NULL);

never executed (the execution status of this line is deduced): zerolength = compile_ref_checks(common, ccbegin, ((void *)0));

3670 /* Restore if not zero length. */ -

3671

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

3672

never executed: }

3673 else -

3674 { -

3675

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

3676

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3677

zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);

never executed (the execution status of this line is deduced): zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);

3678

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);

never executed: }

3679 -

3680

if (min > 1 || max > 1)

never evaluated: min > 1

never evaluated: max > 1

3681

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (0));

3682 -

3683

compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, FALSE, FALSE);

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

3684

never executed (the execution status of this line is deduced): compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, 0, 0);

3685 -

3686

if (min > 1 || max > 1)

never evaluated: min > 1

never evaluated: max > 1

3687 { -

3688

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

3689

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

3690

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (1), (0));

3691

if (min > 1)

never evaluated: min > 1

3692

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, label);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (min)), (label));

3693

if (max > 1)

never evaluated: max > 1

3694 { -

3695

jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (3), (1), (0), (0x200), (max));

3696

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

3697

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3698

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (label));

3699

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

never executed: }

never executed: }

3702 -

3703

if (max == 0)

never evaluated: max == 0

3704 { -

3705 /* Includes min > 1 case as well. */ -

3706

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

3707

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3708

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (label));

3709

never executed: }

3710 -

3711

JUMPHERE(zerolength);

never executed (the execution status of this line is deduced): sljit_set_label((zerolength), sljit_emit_label(compiler));

3712

never executed (the execution status of this line is deduced): ((iterator_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

3713 -

3714

never executed (the execution status of this line is deduced): decrease_call_count(common);

3715

never executed: return cc;

3716 } -

3717 -

3718

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 2);

3719

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3720

if (type != OP_CRMINSTAR)

never evaluated: type != OP_CRMINSTAR

3721

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3722 -

3723

if (min == 0)

never evaluated: min == 0

3724 { -

3725

zerolength = compile_ref_checks(common, ccbegin, NULL);

never executed (the execution status of this line is deduced): zerolength = compile_ref_checks(common, ccbegin, ((void *)0));

3726

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3727

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (22));

3728

zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);

never executed: }

3729 else -

3730

never executed: zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);

3731 -

3732

add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));

never executed (the execution status of this line is deduced): ((iterator_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

3733

if (max > 0)

never evaluated: max > 0

3734

never executed:

add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (3), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (max)));

3735 -

3736

compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, TRUE, TRUE);

never executed (the execution status of this line is deduced): compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, 1, 1);

3737

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3738 -

3739

if (min > 1)

never evaluated: min > 1

3740 { -

3741

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

3742

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

3743

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (1), (0));

3744

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, FALLBACK_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (min)), (((iterator_fallback*)fallback)->hotpath));

never executed: }

never evaluated: max > 0

3747

OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);

never executed:

sljit_emit_op2(compiler, (23), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

3748 -

3749

never evaluated: jump != ((void *)0)

3750

never executed: sljit_set_label((jump), sljit_emit_label(compiler));

3751

JUMPHERE(zerolength);

never executed (the execution status of this line is deduced): sljit_set_label((zerolength), sljit_emit_label(compiler));

3752 -

3753

never executed (the execution status of this line is deduced): decrease_call_count(common);

3754

never executed: return cc;

3755 } -

3756 -

3757 static SLJIT_INLINE pcre_uchar *compile_recurse_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent) -

3758 { -

3759

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

3760

recurse_entry *entry = common->entries;

never executed (the execution status of this line is deduced): fallback_common *fallback;

3761

never executed (the execution status of this line is deduced): recurse_entry *entry = common->entries;

3762

recurse_entry *prev = NULL;

never executed (the execution status of this line is deduced): recurse_entry *prev = ((void *)0);

3763

int start = GET(cc, 1);

never executed (the execution status of this line is deduced): int start = (cc[1]);

3764 -

3765

PUSH_FALLBACK(sizeof(recurse_fallback), cc, NULL);

never executed: return ((void *)0);

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

3766

while (entry != NULL)

never evaluated: entry != ((void *)0)

3767 { -

3768

if (entry->start == start)

never evaluated: entry->start == start

3769

never executed: break;

3770

prev = entry;

never executed (the execution status of this line is deduced): prev = entry;

3771

entry = entry->next;

never executed (the execution status of this line is deduced): entry = entry->next;

3772

entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));

never executed: }

3773 -

3774

if (entry == NULL)

never evaluated: entry == ((void *)0)

3775 { -

3776

never executed (the execution status of this line is deduced): entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));

3777

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

3778

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));

never executed: return ((void *)0);

3779

entry->next = NULL;

never executed (the execution status of this line is deduced): entry->next = ((void *)0);

3780

entry->entry = NULL;

never executed (the execution status of this line is deduced): entry->entry = ((void *)0);

3781

entry->calls = NULL;

never executed (the execution status of this line is deduced): entry->calls = ((void *)0);

3782

entry->start = start;

never executed (the execution status of this line is deduced): entry->start = start;

3783 -

3784

if (prev != NULL)

never evaluated: prev != ((void *)0)

3785

prev->next = entry;

never executed: prev->next = entry;

3786 else -

3787

common->entries = entry;

never executed: common->entries = entry;

3788 } -

3789 -

3790

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))));

3791

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

3792

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (3), (0));

3793 -

3794

if (entry->entry == NULL)

never evaluated: entry->entry == ((void *)0)

3795

add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));

never executed: add_jump(compiler, &entry->calls, sljit_emit_jump(compiler, (23)));

3796 else -

3797

JUMPTO(SLJIT_FAST_CALL, entry->entry);

never executed: sljit_set_label(sljit_emit_jump(compiler, (23)), (entry->entry));

3798 /* Leave if the match is failed. */ -

3799

add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (0)));

3800

never executed: return cc + 1 + 1;

3801 } -

3802 -

3803 static pcre_uchar *compile_assert_hotpath(compiler_common *common, pcre_uchar *cc, assert_fallback *fallback, BOOL conditional) -

3804 { -

3805

fallback_common altfallback;

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

3806

int framesize;

never executed (the execution status of this line is deduced): int framesize;

3807

int localptr;

never executed (the execution status of this line is deduced): int localptr;

3808

never executed (the execution status of this line is deduced): fallback_common altfallback;

3809

never executed (the execution status of this line is deduced): pcre_uchar *ccbegin;

3810

never executed (the execution status of this line is deduced): pcre_uchar opcode;

3811

jump_list **target = (conditional) ? &fallback->condfailed : &fallback->common.topfallbacks;

never executed (the execution status of this line is deduced): pcre_uchar bra = OP_BRA;

3812

jump_list *tmp = NULL;

never executed (the execution status of this line is deduced): jump_list *tmp = ((void *)0);

3813

never evaluated: (conditional)

3814

jump_list **found;

never executed (the execution status of this line is deduced): jump_list **found;

3815 /* Saving previous accept variables. */ -

3816

struct sljit_label *save_acceptlabel = common->acceptlabel;

never executed (the execution status of this line is deduced): struct sljit_label *save_acceptlabel = common->acceptlabel;

3817

struct sljit_jump *brajump = NULL;

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

3818

never executed (the execution status of this line is deduced): struct sljit_jump *brajump = ((void *)0);

3819

jump_list *save_accept = common->accept;

never executed (the execution status of this line is deduced): jump_list *save_accept = common->accept;

3820 -

3821

if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)

never evaluated: *cc == OP_BRAZERO

never evaluated: *cc == OP_BRAMINZERO

3822 { -

3823

SLJIT_ASSERT(!conditional);

never executed: }

never evaluated: 0

3824

never executed (the execution status of this line is deduced): bra = *cc;

3825

never executed (the execution status of this line is deduced): cc++;

3826

localptr = PRIV_DATA(cc);

never executed: }

3827

never executed (the execution status of this line is deduced): localptr = (common->localptrs[(cc) - common->start]);

3828

SLJIT_ASSERT(localptr != 0);

never executed: }

never evaluated: 0

3829

framesize = get_framesize(common, cc, FALSE);

never executed (the execution status of this line is deduced): framesize = get_framesize(common, cc, 0);

3830

fallback->framesize = framesize;

never executed (the execution status of this line is deduced): fallback->framesize = framesize;

3831

fallback->localptr = localptr;

never executed (the execution status of this line is deduced): fallback->localptr = localptr;

3832

SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);

never executed (the execution status of this line is deduced): opcode = *cc;

3833

never executed: }

never evaluated: 0

3834

found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;

never evaluated: opcode == OP_ASSERT

never evaluated: opcode == OP_ASSERTBACK

3835

never executed (the execution status of this line is deduced): ccbegin = cc;

3836

if (bra == OP_BRAMINZERO)

never executed (the execution status of this line is deduced): cc += (cc[1]);

3837 -

3838

never evaluated: bra == OP_BRAMINZERO

3839 { -

3840 /* This is a braminzero fallback path. */ -

3841

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

3842

brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

3843

never executed (the execution status of this line is deduced): brajump = sljit_emit_cmp(compiler, (0), (6), (0), (0x200), (0));

3844

never executed: }

3845 -

3846

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);

never evaluated: framesize < 0

3847 { -

3848

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (2), (0));

3849

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

3850

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3851

allocate_stack(common, framesize + 2);

never executed: }

3852 else -

3853 { -

3854

never executed (the execution status of this line is deduced): allocate_stack(common, framesize + 2);

3855

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

3856

OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + 1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (3), (0), (2), (0), (0x200), (-((-(framesize + 1) - 1) * (int)sizeof(sljit_w))));

3857

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (3), (0));

3858

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

3859

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (1), (0));

3860

init_frame(common, ccbegin, framesize + 1, 2, FALSE);

never executed (the execution status of this line is deduced): init_frame(common, ccbegin, framesize + 1, 2, 0);

3861

memset(&altfallback, 0, sizeof(fallback_common));

never executed: }

3862 -

3863

never executed (the execution status of this line is deduced): memset(&altfallback, 0, sizeof(fallback_common));

3864

while (1)

never evaluated: 1

3865 { -

3866

common->acceptlabel = NULL;

never executed (the execution status of this line is deduced): common->acceptlabel = ((void *)0);

3867

common->accept = NULL;

never executed (the execution status of this line is deduced): common->accept = ((void *)0);

3868

altfallback.top = NULL;

never executed (the execution status of this line is deduced): altfallback.top = ((void *)0);

3869

altfallback.topfallbacks = NULL;

never executed (the execution status of this line is deduced): altfallback.topfallbacks = ((void *)0);

3870 -

3871

if (*ccbegin == OP_ALT)

never evaluated: *ccbegin == OP_ALT

3872

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

3873 -

3874

altfallback.cc = ccbegin;

never executed (the execution status of this line is deduced): altfallback.cc = ccbegin;

3875

compile_hotpath(common, ccbegin + 1 + LINK_SIZE, cc, &altfallback);

never executed (the execution status of this line is deduced): compile_hotpath(common, ccbegin + 1 + 1, cc, &altfallback);

3876

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

3877 { -

3878

common->acceptlabel = save_acceptlabel;

never executed (the execution status of this line is deduced): common->acceptlabel = save_acceptlabel;

3879

common->accept = save_accept;

never executed (the execution status of this line is deduced): common->accept = save_accept;

3880

common->acceptlabel = LABEL();

never executed: return ((void *)0);

3881 } -

3882

never executed (the execution status of this line is deduced): common->acceptlabel = sljit_emit_label(compiler);

3883

if (common->accept != NULL)

never evaluated: common->accept != ((void *)0)

3884

set_jumps(common->accept, common->acceptlabel);

never executed: set_jumps(common->accept, common->acceptlabel);

3885 -

3886 /* Reset stack. */ -

3887

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never evaluated: framesize < 0

3888

never executed: sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

3889 else { -

3890

if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)

never evaluated: opcode != OP_ASSERT_NOT

never evaluated: opcode != OP_ASSERTBACK_NOT

never evaluated: conditional

3891 { -

3892 /* We don't need to keep the STR_PTR, only the previous localptr. */ -

3893

OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), ((0x100 | (11))), (localptr), (0x200), ((framesize + 1) * sizeof(sljit_w)));

3894

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed: }

3895 else -

3896 { -

3897

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

3898

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

3899

if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)

never executed: }

3900 } -

3901 -

3902

never evaluated: opcode == OP_ASSERT_NOT

never evaluated: opcode == OP_ASSERTBACK_NOT

3903 { -

3904 /* We know that STR_PTR was stored on the top of the stack. */ -

3905

if (conditional)

never evaluated: conditional

3906

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (0));

3907

else if (bra == OP_BRAZERO)

never evaluated: bra == OP_BRAZERO

3908 { -

3909

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);

never evaluated: framesize < 0

3910

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (0));

3911 else -

3912 { -

3913

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (framesize * sizeof(sljit_w)));

3914

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), ((framesize + 1) * sizeof(sljit_w)));

3915

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (1), (0));

3916

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never executed: }

3917

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

3918

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3919

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));

never executed: }

3920

else if (framesize >= 0)

never evaluated: framesize >= 0

3921 { -

3922 /* For OP_BRA and OP_BRAMINZERO. */ -

3923

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (framesize * sizeof(sljit_w)));

3924

add_jump(compiler, found, JUMP(SLJIT_JUMP));

never executed: }

3925 } -

3926

never executed (the execution status of this line is deduced): add_jump(compiler, found, sljit_emit_jump(compiler, (22)));

3927 -

3928

compile_fallbackpath(common, altfallback.top);

never executed (the execution status of this line is deduced): compile_fallbackpath(common, altfallback.top);

3929

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

3930 { -

3931

common->acceptlabel = save_acceptlabel;

never executed (the execution status of this line is deduced): common->acceptlabel = save_acceptlabel;

3932

common->accept = save_accept;

never executed (the execution status of this line is deduced): common->accept = save_accept;

3933

set_jumps(altfallback.topfallbacks, LABEL());

never executed: return ((void *)0);

3934 } -

3935

never executed (the execution status of this line is deduced): set_jumps(altfallback.topfallbacks, sljit_emit_label(compiler));

3936 -

3937

if (*cc != OP_ALT)

never evaluated: *cc != OP_ALT

3938

never executed: break;

3939 -

3940

never executed (the execution status of this line is deduced): ccbegin = cc;

3941

never executed (the execution status of this line is deduced): cc += (cc[1]);

3942

if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)

never executed: }

3943 /* None of them matched. */ -

3944 -

3945

never evaluated: opcode == OP_ASSERT

never evaluated: opcode == OP_ASSERTBACK

3946 { -

3947 /* Assert is failed. */ -

3948

if (conditional || bra == OP_BRAZERO)

never evaluated: conditional

never evaluated: bra == OP_BRAZERO

3949

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

3950 -

3951

never evaluated: framesize < 0

3952 { -

3953 /* The topmost item should be 0. */ -

3954

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never evaluated: bra == OP_BRAZERO

3955

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3956 else -

3957

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed: free_stack(common, 1);

3958 } -

3959 else -

3960 { -

3961

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

3962 /* The topmost item should be 0. */ -

3963

free_stack(common, framesize + 1);

never evaluated: bra == OP_BRAZERO

3964 { -

3965

never executed (the execution status of this line is deduced): free_stack(common, framesize + 1);

3966

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3967

free_stack(common, framesize + 2);

never executed: }

3968 else -

3969

never executed: free_stack(common, framesize + 2);

3970

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (1), (0));

3971

never executed: }

3972

add_jump(compiler, target, jump);

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (22));

3973

if (bra != OP_BRAZERO)

never evaluated: bra != OP_BRAZERO

3974

never executed: add_jump(compiler, target, jump);

3975 -

3976 /* Assert is successful. */ -

3977

set_jumps(tmp, LABEL());

never executed (the execution status of this line is deduced): set_jumps(tmp, sljit_emit_label(compiler));

3978

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);

never evaluated: framesize < 0

3979 { -

3980 /* We know that STR_PTR was stored on the top of the stack. */ -

3981

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (0));

3982 /* Keep the STR_PTR on the top of the stack. */ -

3983

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never evaluated: bra == OP_BRAZERO

3984

never executed: sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

3985

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never evaluated: bra == OP_BRAMINZERO

3986 { -

3987

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

3988

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

3989

OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));

never executed: }

3990 } -

3991 else -

3992 { -

3993

if (bra == OP_BRA)

never evaluated: bra == OP_BRA

3994 { -

3995 /* We don't need to keep the STR_PTR, only the previous localptr. */ -

3996

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), ((0x100 | (11))), (localptr), (0x200), ((framesize + 1) * sizeof(sljit_w)));

3997

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (0));

3998

OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_w));

never executed: }

3999 else -

4000 { -

4001 /* We don't need to keep the STR_PTR, only the previous localptr. */ -

4002

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), ((0x100 | (11))), (localptr), (0x200), ((framesize + 2) * sizeof(sljit_w)));

4003

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

4004

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (bra == OP_BRAZERO ? 6 : 0x200), (0));

4005

never executed: }

4006 } -

4007 -

4008

fallback->hotpath = LABEL();

never evaluated: bra == OP_BRAZERO

4009 { -

4010

never executed (the execution status of this line is deduced): fallback->hotpath = sljit_emit_label(compiler);

4011

sljit_set_label(jump, fallback->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(jump, fallback->hotpath);

4012

never executed: }

4013

JUMPTO(SLJIT_JUMP, fallback->hotpath);

never evaluated: bra == OP_BRAMINZERO

4014 { -

4015

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (fallback->hotpath));

4016

JUMPHERE(brajump);

never executed (the execution status of this line is deduced): sljit_set_label((brajump), sljit_emit_label(compiler));

4017

if (framesize >= 0)

never evaluated: framesize >= 0

4018 { -

4019

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

4020

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

4021

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (framesize * sizeof(sljit_w)));

4022

set_jumps(fallback->common.topfallbacks, LABEL());

never executed: }

4023

never executed (the execution status of this line is deduced): set_jumps(fallback->common.topfallbacks, sljit_emit_label(compiler));

4024

never executed: }

4025 } -

4026 else -

4027 { -

4028 /* AssertNot is successful. */ -

4029

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never evaluated: framesize < 0

4030 { -

4031

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

4032

if (bra != OP_BRA)

never evaluated: bra != OP_BRA

4033

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4034 else -

4035

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: free_stack(common, 1);

4036 } -

4037 else -

4038 { -

4039

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

4040

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

4041 /* The topmost item should be 0. */ -

4042

if (bra != OP_BRA)

never evaluated: bra != OP_BRA

4043 { -

4044

free_stack(common, framesize + 1);

never executed (the execution status of this line is deduced): free_stack(common, framesize + 1);

4045

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4046

free_stack(common, framesize + 2);

never executed: }

4047 else -

4048

never executed: free_stack(common, framesize + 2);

4049

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (1), (0));

4050

never executed: }

4051 -

4052

fallback->hotpath = LABEL();

never evaluated: bra == OP_BRAZERO

4053

never executed: fallback->hotpath = sljit_emit_label(compiler);

4054

JUMPTO(SLJIT_JUMP, fallback->hotpath);

never evaluated: bra == OP_BRAMINZERO

4055 { -

4056

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (fallback->hotpath));

4057

JUMPHERE(brajump);

never executed (the execution status of this line is deduced): sljit_set_label((brajump), sljit_emit_label(compiler));

4058

SLJIT_ASSERT(found == &fallback->common.topfallbacks);

never executed: }

4059 -

4060

if (bra != OP_BRA)

never evaluated: bra != OP_BRA

4061 { -

4062

never executed: }

never evaluated: 0

4063

set_jumps(fallback->common.topfallbacks, LABEL());

never executed (the execution status of this line is deduced): set_jumps(fallback->common.topfallbacks, sljit_emit_label(compiler));

4064

fallback->common.topfallbacks = NULL;

never executed (the execution status of this line is deduced): fallback->common.topfallbacks = ((void *)0);

never executed: }

never executed: }

4067 -

4068

common->acceptlabel = save_acceptlabel;

never executed (the execution status of this line is deduced): common->acceptlabel = save_acceptlabel;

4069

common->accept = save_accept;

never executed (the execution status of this line is deduced): common->accept = save_accept;

4070

pcre_uchar *slotA = name_table;

never executed: return cc + 1 + 1;

4071 } -

4072 -

4073 static sljit_w SLJIT_CALL do_searchovector(sljit_w refno, sljit_w* locals, pcre_uchar *name_table) -

4074 { -

4075

int condition = FALSE;

never executed (the execution status of this line is deduced): int condition = 0;

4076

never executed (the execution status of this line is deduced): pcre_uchar *slotA = name_table;

4077

pcre_uchar *slotB;

never executed (the execution status of this line is deduced): pcre_uchar *slotB;

4078

sljit_w name_count = locals[LOCALS0 / sizeof(sljit_w)];

never executed (the execution status of this line is deduced): sljit_w name_count = locals[(0 * sizeof(sljit_w)) / sizeof(sljit_w)];

4079

sljit_w name_entry_size = locals[LOCALS1 / sizeof(sljit_w)];

never executed (the execution status of this line is deduced): sljit_w name_entry_size = locals[(1 * sizeof(sljit_w)) / sizeof(sljit_w)];

4080

sljit_w no_capture;

never executed (the execution status of this line is deduced): sljit_w no_capture;

4081

int i;

never executed (the execution status of this line is deduced): int i;

4082 -

4083

locals += OVECTOR_START / sizeof(sljit_w);

never executed (the execution status of this line is deduced): locals += (8 * sizeof(sljit_w)) / sizeof(sljit_w);

4084

no_capture = locals[1];

never executed (the execution status of this line is deduced): no_capture = locals[1];

4085 -

4086

for (i = 0; i < name_count; i++)

never evaluated: i < name_count

4087 { -

4088

if (GET2(slotA, 0) == refno) break;

never executed: break;

never evaluated: slotA[0] == refno

4089

slotA += name_entry_size;

never executed (the execution status of this line is deduced): slotA += name_entry_size;

4090

never executed: }

4091 -

4092

if (i < name_count)

never evaluated: i < name_count

4093 { -

4094 /* Found a name for the number - there can be only one; duplicate names -

4095 for different numbers are allowed, but not vice versa. First scan down -

4096 for duplicates. */ -

4097 -

4098

while (slotB > name_table)

never executed (the execution status of this line is deduced): slotB = slotA;

4099

never evaluated: slotB > name_table

4100 { -

4101

slotB -= name_entry_size;

never executed (the execution status of this line is deduced): slotB -= name_entry_size;

4102

if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)

never evaluated: _pcre16_strcmp_uc_uc((slotA + 1), (slotB + 1)) == 0

4103 { -

4104

condition = locals[GET2(slotB, 0) << 1] != no_capture;

never executed (the execution status of this line is deduced): condition = locals[slotB[0] << 1] != no_capture;

4105

never executed: break;

never evaluated: condition

never executed: }

never executed: break;

4108 } -

4109 -

4110 /* Scan up for duplicates */ -

4111

if (!condition)

never evaluated: !condition

4112 { -

4113

for (i++; i < name_count; i++)

never executed (the execution status of this line is deduced): slotB = slotA;

4114

never evaluated: i < name_count

4115 { -

4116

slotB += name_entry_size;

never executed (the execution status of this line is deduced): slotB += name_entry_size;

4117

if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)

never evaluated: _pcre16_strcmp_uc_uc((slotA + 1), (slotB + 1)) == 0

4118 { -

4119

condition = locals[GET2(slotB, 0) << 1] != no_capture;

never executed (the execution status of this line is deduced): condition = locals[slotB[0] << 1] != no_capture;

4120

pcre_uchar *slotA = name_table;

never executed: break;

never evaluated: condition

never executed: }

never executed: break;

4123 } -

never executed: }

never executed: }

never executed: return condition;

4127 } -

4128 -

4129 static sljit_w SLJIT_CALL do_searchgroups(sljit_w recno, sljit_w* locals, pcre_uchar *name_table) -

4130 { -

4131

int condition = FALSE;

never executed (the execution status of this line is deduced): int condition = 0;

4132

never executed (the execution status of this line is deduced): pcre_uchar *slotA = name_table;

4133

pcre_uchar *slotB;

never executed (the execution status of this line is deduced): pcre_uchar *slotB;

4134

sljit_w name_count = locals[LOCALS0 / sizeof(sljit_w)];

never executed (the execution status of this line is deduced): sljit_w name_count = locals[(0 * sizeof(sljit_w)) / sizeof(sljit_w)];

4135

sljit_w name_entry_size = locals[LOCALS1 / sizeof(sljit_w)];

never executed (the execution status of this line is deduced): sljit_w name_entry_size = locals[(1 * sizeof(sljit_w)) / sizeof(sljit_w)];

4136

sljit_w group_num = locals[POSSESSIVE0 / sizeof(sljit_w)];

never executed (the execution status of this line is deduced): sljit_w group_num = locals[(2 * sizeof(sljit_w)) / sizeof(sljit_w)];

4137

int i;

never executed (the execution status of this line is deduced): int i;

4138 -

4139

for (i = 0; i < name_count; i++)

never evaluated: i < name_count

4140 { -

4141

if (GET2(slotA, 0) == recno) break;

never executed: break;

never evaluated: slotA[0] == recno

4142

slotA += name_entry_size;

never executed (the execution status of this line is deduced): slotA += name_entry_size;

4143

never executed: }

4144 -

4145

if (i < name_count)

never evaluated: i < name_count

4146 { -

4147 /* Found a name for the number - there can be only one; duplicate -

4148 names for different numbers are allowed, but not vice versa. First -

4149 scan down for duplicates. */ -

4150 -

4151

while (slotB > name_table)

never executed (the execution status of this line is deduced): slotB = slotA;

4152

never evaluated: slotB > name_table

4153 { -

4154

slotB -= name_entry_size;

never executed (the execution status of this line is deduced): slotB -= name_entry_size;

4155

if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)

never evaluated: _pcre16_strcmp_uc_uc((slotA + 1), (slotB + 1)) == 0

4156 { -

4157

condition = GET2(slotB, 0) == group_num;

never executed (the execution status of this line is deduced): condition = slotB[0] == group_num;

4158

never executed: break;

never evaluated: condition

never executed: }

never executed: break;

4161 } -

4162 -

4163 /* Scan up for duplicates */ -

4164

if (!condition)

never evaluated: !condition

4165 { -

4166

for (i++; i < name_count; i++)

never executed (the execution status of this line is deduced): slotB = slotA;

4167

never evaluated: i < name_count

4168 { -

4169

slotB += name_entry_size;

never executed (the execution status of this line is deduced): slotB += name_entry_size;

4170

if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)

never evaluated: _pcre16_strcmp_uc_uc((slotA + 1), (slotB + 1)) == 0

4171 { -

4172

condition = GET2(slotB, 0) == group_num;

never executed (the execution status of this line is deduced): condition = slotB[0] == group_num;

4173

never executed: break;

never evaluated: condition

never executed: }

never executed: break;

4176 } -

never executed: }

never executed: }

never executed: return condition;

4180 } -

4181 -

4182 /* -

4183 Handling bracketed expressions is probably the most complex part. -

4184 -

4185 Stack layout naming characters: -

4186 S - Push the current STR_PTR -

4187 0 - Push a 0 (NULL) -

4188 A - Push the current STR_PTR. Needed for restoring the STR_PTR -

4189 before the next alternative. Not pushed if there are no alternatives. -

4190 M - Any values pushed by the current alternative. Can be empty, or anything. -

4191 C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack. -

4192 L - Push the previous local (pointed by localptr) to the stack -

4193 () - opional values stored on the stack -

4194 ()* - optonal, can be stored multiple times -

4195 -

4196 The following list shows the regular expression templates, their PCRE byte codes -

4197 and stack layout supported by pcre-sljit. -

4198 -

4199 (?:) OP_BRA | OP_KET A M -

4200 () OP_CBRA | OP_KET C M -

4201 (?:)+ OP_BRA | OP_KETRMAX 0 A M S ( A M S )* -

4202 OP_SBRA | OP_KETRMAX 0 L M S ( L M S )* -

4203 (?:)+? OP_BRA | OP_KETRMIN 0 A M S ( A M S )* -

4204 OP_SBRA | OP_KETRMIN 0 L M S ( L M S )* -

4205 ()+ OP_CBRA | OP_KETRMAX 0 C M S ( C M S )* -

4206 OP_SCBRA | OP_KETRMAX 0 C M S ( C M S )* -

4207 ()+? OP_CBRA | OP_KETRMIN 0 C M S ( C M S )* -

4208 OP_SCBRA | OP_KETRMIN 0 C M S ( C M S )* -

4209 (?:)? OP_BRAZERO | OP_BRA | OP_KET S ( A M 0 ) -

4210 (?:)?? OP_BRAMINZERO | OP_BRA | OP_KET S ( A M 0 ) -

4211 ()? OP_BRAZERO | OP_CBRA | OP_KET S ( C M 0 ) -

4212 ()?? OP_BRAMINZERO | OP_CBRA | OP_KET S ( C M 0 ) -

4213 (?:)* OP_BRAZERO | OP_BRA | OP_KETRMAX S 0 ( A M S )* -

4214 OP_BRAZERO | OP_SBRA | OP_KETRMAX S 0 ( L M S )* -

4215 (?:)*? OP_BRAMINZERO | OP_BRA | OP_KETRMIN S 0 ( A M S )* -

4216 OP_BRAMINZERO | OP_SBRA | OP_KETRMIN S 0 ( L M S )* -

4217 ()* OP_BRAZERO | OP_CBRA | OP_KETRMAX S 0 ( C M S )* -

4218 OP_BRAZERO | OP_SCBRA | OP_KETRMAX S 0 ( C M S )* -

4219 ()*? OP_BRAMINZERO | OP_CBRA | OP_KETRMIN S 0 ( C M S )* -

4220 OP_BRAMINZERO | OP_SCBRA | OP_KETRMIN S 0 ( C M S )* -

4221 -

4222 -

4223 Stack layout naming characters: -

4224 A - Push the alternative index (starting from 0) on the stack. -

4225 Not pushed if there is no alternatives. -

4226 M - Any values pushed by the current alternative. Can be empty, or anything. -

4227 -

4228 The next list shows the possible content of a bracket: -

4229 (|) OP_*BRA | OP_ALT ... M A -

4230 (?()|) OP_*COND | OP_ALT M A -

4231 (?>|) OP_ONCE | OP_ALT ... [stack trace] M A -

4232 (?>|) OP_ONCE_NC | OP_ALT ... [stack trace] M A -

4233 Or nothing, if trace is unnecessary -

4234 */ -

4235 -

4236 static pcre_uchar *compile_bracket_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent) -

4237 { -

4238

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

4239

executed (the execution status of this line is deduced): fallback_common *fallback;

4240

executed (the execution status of this line is deduced): pcre_uchar opcode;

4241

int localptr = 0;

executed (the execution status of this line is deduced): int localptr = 0;

4242

int offset = 0;

executed (the execution status of this line is deduced): int offset = 0;

4243

int stacksize;

executed (the execution status of this line is deduced): int stacksize;

4244

executed (the execution status of this line is deduced): pcre_uchar *ccbegin;

4245

pcre_uchar *hotpath;

executed (the execution status of this line is deduced): pcre_uchar *hotpath;

4246

executed (the execution status of this line is deduced): pcre_uchar bra = OP_BRA;

4247

pcre_uchar ket;

executed (the execution status of this line is deduced): pcre_uchar ket;

4248

assert_fallback *assert;

executed (the execution status of this line is deduced): assert_fallback *assert;

4249

BOOL has_alternatives;

executed (the execution status of this line is deduced): BOOL has_alternatives;

4250

struct sljit_label *rmaxlabel = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *jump;

4251

struct sljit_jump *skip;

executed (the execution status of this line is deduced): struct sljit_jump *skip;

4252

executed (the execution status of this line is deduced): struct sljit_label *rmaxlabel = ((void *)0);

4253

struct sljit_jump *braminzerojump = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *braminzerojump = ((void *)0);

4254 -

4255

PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);

never executed: return ((void *)0);

executed: }

Execution Count:15

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4256 -

4257

if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)

partially evaluated: *cc == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: *cc == OP_BRAMINZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4258 { -

4259

never executed (the execution status of this line is deduced): bra = *cc;

4260

never executed (the execution status of this line is deduced): cc++;

4261

never executed (the execution status of this line is deduced): opcode = *cc;

4262

never executed: }

4263 -

4264

executed (the execution status of this line is deduced): opcode = *cc;

4265

hotpath = ccbegin + 1 + LINK_SIZE;

executed (the execution status of this line is deduced): ccbegin = cc;

4266

executed (the execution status of this line is deduced): hotpath = ccbegin + 1 + 1;

4267 -

4268

if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)

partially evaluated: opcode == OP_COND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCOND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

never evaluated: cc[1 + 1] == OP_DEF

0-15

4269 { -

4270 /* Drop this bracket_fallback. */ -

4271

parent->top = fallback->prev;

never executed (the execution status of this line is deduced): parent->top = fallback->prev;

4272

return bracketend(cc);

never executed: return bracketend(cc);

4273 } -

4274 -

4275

ket = *(bracketend(cc) - 1 - LINK_SIZE);

executed (the execution status of this line is deduced): ket = *(bracketend(cc) - 1 - 1);

4276

SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);

executed: }

Execution Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4277

SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));

executed: }

Execution Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4278

has_alternatives = *cc == OP_ALT;

executed (the execution status of this line is deduced): cc += (cc[1]);

4279 -

4280

executed (the execution status of this line is deduced): has_alternatives = *cc == OP_ALT;

4281

if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))

partially evaluated: __builtin_expect((opcode == OP_COND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: __builtin_expect((opcode == OP_SCOND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4282 { -

4283

has_alternatives = (*hotpath == OP_RREF) ? FALSE : TRUE;

never evaluated: (*hotpath == OP_RREF)

4284

if (*hotpath == OP_NRREF)

never evaluated: *hotpath == OP_NRREF

4285 { -

4286

if (common->currententry == NULL || stacksize == RREF_ANY)

never executed (the execution status of this line is deduced): stacksize = hotpath[1];

4287

never evaluated: common->currententry == ((void *)0)

never evaluated: stacksize == 0xffff

4288

has_alternatives = FALSE;

never executed: has_alternatives = 0;

4289

else if (common->currententry->start == 0)

never evaluated: common->currententry->start == 0

4290

has_alternatives = stacksize != 0;

never executed: has_alternatives = stacksize != 0;

4291 else -

4292

has_alternatives = stacksize != GET2(common->start, common->currententry->start + 1 + LINK_SIZE);

never executed: has_alternatives = stacksize != common->start[common->currententry->start + 1 + 1];

4293 } -

4294

if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))

never executed: }

4295 -

4296

partially evaluated: __builtin_expect((opcode == OP_COND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

never evaluated: *cc == OP_KETRMAX

never evaluated: *cc == OP_KETRMIN

0-15

4297

opcode = OP_SCOND;

never executed: opcode = OP_SCOND;

4298

if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))

partially evaluated: __builtin_expect((opcode == OP_ONCE_NC), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4299

opcode = OP_ONCE;

never executed: opcode = OP_ONCE;

4300 -

4301

if (opcode == OP_CBRA || opcode == OP_SCBRA)

partially evaluated: opcode == OP_CBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4302 { -

4303 /* Capturing brackets has a pre-allocated space. */ -

4304

offset = GET2(ccbegin, 1 + LINK_SIZE);

never executed (the execution status of this line is deduced): offset = ccbegin[1 + 1];

4305

localptr = OVECTOR_PRIV(offset);

never executed (the execution status of this line is deduced): localptr = (common->cbraptr + (offset) * sizeof(sljit_w));

4306

offset <<= 1;

never executed (the execution status of this line is deduced): offset <<= 1;

4307

FALLBACK_AS(bracket_fallback)->localptr = localptr;

never executed (the execution status of this line is deduced): ((bracket_fallback*)fallback)->localptr = localptr;

4308

hotpath += IMM2_SIZE;

never executed (the execution status of this line is deduced): hotpath += 1;

4309

else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)

never executed: }

4310

partially evaluated: opcode == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCOND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4311 { -

4312 /* Other brackets simply allocate the next entry. */ -

4313

localptr = PRIV_DATA(ccbegin);

never executed (the execution status of this line is deduced): localptr = (common->localptrs[(ccbegin) - common->start]);

4314

SLJIT_ASSERT(localptr != 0);

never executed: }

never evaluated: 0

4315

FALLBACK_AS(bracket_fallback)->localptr = localptr;

never executed (the execution status of this line is deduced): ((bracket_fallback*)fallback)->localptr = localptr;

4316

FALLBACK_AS(bracket_fallback)->u.framesize = get_framesize(common, ccbegin, FALSE);

never evaluated: opcode == OP_ONCE

4317

never executed: ((bracket_fallback*)fallback)->u.framesize = get_framesize(common, ccbegin, 0);

4318

never executed: }

4319 -

4320 /* Instructions before the first alternative. */ -

4321

if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))

executed (the execution status of this line is deduced): stacksize = 0;

4322

partially evaluated: (ket == OP_KETRMAX)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: ket == OP_KETRMIN

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

never evaluated: bra != OP_BRAMINZERO

0-15

4323

never executed: stacksize++;

4324

partially evaluated: bra == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4325

never executed: stacksize++;

4326 -

4327

if (stacksize > 0)

partially evaluated: stacksize > 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4328

never executed: allocate_stack(common, stacksize);

4329 -

4330

if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))

executed (the execution status of this line is deduced): stacksize = 0;

4331

partially evaluated: (ket == OP_KETRMAX)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: ket == OP_KETRMIN

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

never evaluated: bra != OP_BRAMINZERO

0-15

4332 { -

4333

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4334

never executed (the execution status of this line is deduced): stacksize++;

4335

never executed: }

4336 -

4337

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);

partially evaluated: bra == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4338

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (6), (0));

4339 -

4340

if (bra == OP_BRAMINZERO)

partially evaluated: bra == OP_BRAMINZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4341 { -

4342 /* This is a fallback path! (Since the hot-path of OP_BRAMINZERO matches to the empty string) */ -

4343

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

4344

if (ket != OP_KETRMIN)

never evaluated: ket != OP_KETRMIN

4345 { -

4346

braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

4347

never executed (the execution status of this line is deduced): braminzerojump = sljit_emit_cmp(compiler, (0), (6), (0), (0x200), (0));

4348

if (opcode == OP_ONCE || opcode >= OP_SBRA)

never executed: }

4349 else -

4350 { -

4351

never evaluated: opcode == OP_ONCE

never evaluated: opcode >= OP_SBRA

4352 { -

4353

jump = CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0));

4354

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

4355 /* Nothing stored during the first run. */ -

4356

skip = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): skip = sljit_emit_jump(compiler, (22));

4357

if (opcode != OP_ONCE || FALLBACK_AS(bracket_fallback)->u.framesize < 0)

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

4358 /* Checking zero-length iteration. */ -

4359

never evaluated: opcode != OP_ONCE

never evaluated: ((bracket_fallback*)fallback)->u.framesize < 0

4360 { -

4361 /* When we come from outside, localptr contains the previous STR_PTR. */ -

4362

braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): braminzerojump = sljit_emit_cmp(compiler, (0), (6), (0), ((0x100 | (11))), (localptr));

4363

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed: }

4364 else -

4365 { -

4366 /* Except when the whole stack frame must be saved. */ -

4367

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

4368

braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (FALLBACK_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w));

never executed (the execution status of this line is deduced):

 braminzerojump = sljit_emit_cmp(compiler, (0), (6), (0), ((0x100 | (1))), ((((bracket_fallback*)fallback)->u.framesize + 1) * sizeof(sljit_w)));

never executed: }

never executed (the execution status of this line is deduced): sljit_set_label((skip), sljit_emit_label(compiler));

4371

jump = CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);

never executed: }

4372 else -

4373 { -

4374

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0));

4375

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

4376

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

4377

FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();

never executed: }

4378 } -

4379 } -

4380 -

4381

if (ket == OP_KETRMIN)

partially evaluated: ket == OP_KETRMIN

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4382

never executed: ((bracket_fallback*)fallback)->recursivehotpath = sljit_emit_label(compiler);

4383 -

4384

if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)

partially evaluated: ket == OP_KETRMAX

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4385 { -

4386

rmaxlabel = LABEL();

never executed (the execution status of this line is deduced): rmaxlabel = sljit_emit_label(compiler);

4387

never evaluated: has_alternatives

never evaluated: opcode != OP_ONCE

never evaluated: opcode < OP_SBRA

4388

FALLBACK_AS(bracket_fallback)->althotpath = rmaxlabel;

never executed: ((bracket_fallback*)fallback)->althotpath = rmaxlabel;

4389

never executed: }

4390 -

4391 /* Handling capturing brackets and alternatives. */ -

4392

if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)

partially evaluated: opcode == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4393 { -

4394

never evaluated: ((bracket_fallback*)fallback)->u.framesize < 0

4395 { -

4396 /* Neither capturing brackets nor recursions are not found in the block. */ -

4397

if (ket == OP_KETRMIN)

never evaluated: ket == OP_KETRMIN

4398 { -

4399

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (localptr));

4400

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 2);

4401

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

4402

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (3), (0));

4403

OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), ((0x100 | (11))), (localptr), (2), (0), (0x200), (sizeof(sljit_w)));

4404

else if (ket == OP_KETRMAX || has_alternatives)

never executed: }

4405

never evaluated: ket == OP_KETRMAX

never evaluated: has_alternatives

4406 { -

4407

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (2), (0));

4408

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

4409

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

4410

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);

never executed: }

4411 else -

4412

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (2), (0));

4413 } -

4414 else -

4415 { -

4416

if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)

never evaluated: ket == OP_KETRMIN

never evaluated: ket == OP_KETRMAX

never evaluated: has_alternatives

4417 { -

4418

allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 2);

never executed (the execution status of this line is deduced): allocate_stack(common, ((bracket_fallback*)fallback)->u.framesize + 2);

4419

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

4420

OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize + 1));

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (25), (3), (0), (2), (0), (0x200), (-((-(((bracket_fallback*)fallback)->u.framesize + 1) - 1) * (int)sizeof(sljit_w))));

4421

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

4422

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (3), (0));

4423

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (1), (0));

4424

init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize + 1, 2, FALSE);

never executed (the execution status of this line is deduced): init_frame(common, ccbegin, ((bracket_fallback*)fallback)->u.framesize + 1, 2, 0);

4425

allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 1);

never executed: }

4426 else -

4427 { -

4428

never executed (the execution status of this line is deduced): allocate_stack(common, ((bracket_fallback*)fallback)->u.framesize + 1);

4429

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

4430

OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize));

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (25), (3), (0), (2), (0), (0x200), (-((-(((bracket_fallback*)fallback)->u.framesize) - 1) * (int)sizeof(sljit_w))));

4431

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (3), (0));

4432

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (1), (0));

4433

init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize, 1, FALSE);

never executed (the execution status of this line is deduced): init_frame(common, ccbegin, ((bracket_fallback*)fallback)->u.framesize, 1, 0);

4434

else if (opcode == OP_CBRA || opcode == OP_SCBRA)

never executed: }

4435 } -

4436 } -

4437

partially evaluated: opcode == OP_CBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4438 { -

4439 /* Saving the previous values. */ -

4440

allocate_stack(common, 3);

never executed (the execution status of this line is deduced): allocate_stack(common, 3);

4441

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))));

4442

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))));

4443

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (1), (0));

4444

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (3), (0));

4445

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

4446

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (6), (0));

4447

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(2) - 1) * (int)sizeof(sljit_w))), (1), (0));

4448

else if (opcode == OP_SBRA || opcode == OP_SCOND)

never executed: }

4449

partially evaluated: opcode == OP_SBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCOND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4450 { -

4451 /* Saving the previous value. */ -

4452

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (localptr));

4453

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

4454

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (6), (0));

4455

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (3), (0));

4456

else if (has_alternatives)

never executed: }

4457

evaluated: has_alternatives

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

4458 { -

4459 /* Pushing the starting string pointer. */ -

4460

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

executed (the execution status of this line is deduced): allocate_stack(common, 1);

4461

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

4462

if (opcode == OP_COND || opcode == OP_SCOND)

executed: }

Execution Count:1

4463 -

4464 /* Generating code for the first alternative. */ -

4465

partially evaluated: opcode == OP_COND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCOND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4466 { -

4467

if (*hotpath == OP_CREF)

never evaluated: *hotpath == OP_CREF

4468 { -

4469

add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed),

never executed: }

never evaluated: 0

4470

never executed (the execution status of this line is deduced): add_jump(compiler, &(((bracket_fallback*)fallback)->u.condfailed),

4471

CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(hotpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));

never executed (the execution status of this line is deduced):

 sljit_emit_cmp(compiler, (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (hotpath[1] << 1) * sizeof(sljit_w))), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w)))));

4472

never executed (the execution status of this line is deduced): hotpath += 1 + 1;

4473

else if (*hotpath == OP_NCREF)

never executed: }

4474

never evaluated: *hotpath == OP_NCREF

4475 { -

4476

never executed: }

never evaluated: 0

4477

jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));

never executed (the execution status of this line is deduced): stacksize = hotpath[1];

4478

never executed (the execution status of this line is deduced):

 jump = sljit_emit_cmp(compiler, (1), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (stacksize << 1) * sizeof(sljit_w))), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w))));

4479 -

4480

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((3 * sizeof(sljit_w))), (2), (0));

4481

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((0 * sizeof(sljit_w))), (0x200), (common->name_count));

4482

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (0x200), (common->name_entry_size));

4483

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), (stacksize));

4484

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), (11), (0));

4485

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (common->name_table));

4486

sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));

never executed (the execution status of this line is deduced): sljit_emit_ijump(compiler, 27, 0x200, ((sljit_w)do_searchovector));

4487

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), ((3 * sizeof(sljit_w))));

4488

add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced):

 add_jump(compiler, &(((bracket_fallback*)fallback)->u.condfailed), sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (0)));

4489 -

4490

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

4491

never executed (the execution status of this line is deduced): hotpath += 1 + 1;

4492

else if (*hotpath == OP_RREF || *hotpath == OP_NRREF)

never executed: }

4493

never evaluated: *hotpath == OP_RREF

never evaluated: *hotpath == OP_NRREF

4494 { -

4495 /* Never has other case. */ -

4496

FALLBACK_AS(bracket_fallback)->u.condfailed = NULL;

never executed (the execution status of this line is deduced): ((bracket_fallback*)fallback)->u.condfailed = ((void *)0);

4497 -

4498

if (common->currententry == NULL)

never executed (the execution status of this line is deduced): stacksize = hotpath[1];

4499

never evaluated: common->currententry == ((void *)0)

4500

else if (stacksize == RREF_ANY)

never executed: stacksize = 0;

4501

never evaluated: stacksize == 0xffff

4502

stacksize = 1;

never executed: stacksize = 1;

4503

else if (common->currententry->start == 0)

never evaluated: common->currententry->start == 0

4504

stacksize = stacksize == 0;

never executed: stacksize = stacksize == 0;

4505 else -

4506

stacksize = stacksize == GET2(common->start, common->currententry->start + 1 + LINK_SIZE);

never executed: stacksize = stacksize == common->start[common->currententry->start + 1 + 1];

4507 -

4508

if (*hotpath == OP_RREF || stacksize || common->currententry == NULL)

never evaluated: *hotpath == OP_RREF

never evaluated: stacksize

never evaluated: common->currententry == ((void *)0)

4509 { -

4510

SLJIT_ASSERT(!has_alternatives);

never executed: }

never evaluated: 0

4511

if (stacksize != 0)

never evaluated: stacksize != 0

4512

hotpath = cc + 1 + LINK_SIZE;

never executed: hotpath += 1 + 1;

4513 else -

4514 { -

4515

if (*cc == OP_ALT)

never evaluated: *cc == OP_ALT

4516 { -

4517

never executed (the execution status of this line is deduced): hotpath = cc + 1 + 1;

4518

never executed (the execution status of this line is deduced): cc += (cc[1]);

4519

never executed: }

4520 else -

4521

hotpath = cc;

never executed: hotpath = cc;

4522 } -

4523 } -

4524 else -

4525 { -

4526

never executed: }

never evaluated: 0

4527 -

4528

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);

never executed (the execution status of this line is deduced): stacksize = hotpath[1];

4529

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((3 * sizeof(sljit_w))), (2), (0));

4530

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((0 * sizeof(sljit_w))), (0x200), (common->name_count));

4531

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (0x200), (common->name_entry_size));

4532

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (common->start[common->currententry->start + 1 + 1]));

4533

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), (stacksize));

4534

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), (11), (0));

4535

OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), (0x200), (common->name_table));

4536

sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));

never executed (the execution status of this line is deduced): sljit_emit_ijump(compiler, 27, 0x200, ((sljit_w)do_searchgroups));

4537

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), ((3 * sizeof(sljit_w))));

4538

add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced):

 add_jump(compiler, &(((bracket_fallback*)fallback)->u.condfailed), sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (0)));

4539

never executed (the execution status of this line is deduced): hotpath += 1 + 1;

4540

SLJIT_ASSERT(has_alternatives && *hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);

never executed: }

4541 } -

4542 else -

4543 { -

4544

never executed: }

never evaluated: 0

4545 /* Similar code as PUSH_FALLBACK macro. */ -

4546

assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));

never executed (the execution status of this line is deduced): assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));

4547

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

4548

memset(assert, 0, sizeof(assert_fallback));

never executed: return ((void *)0);

4549

never executed (the execution status of this line is deduced): memset(assert, 0, sizeof(assert_fallback));

4550

assert->common.cc = hotpath;

never executed (the execution status of this line is deduced): assert->common.cc = hotpath;

4551

FALLBACK_AS(bracket_fallback)->u.assert = assert;

never executed (the execution status of this line is deduced): ((bracket_fallback*)fallback)->u.assert = assert;

4552

hotpath = compile_assert_hotpath(common, hotpath, assert, TRUE);

never executed (the execution status of this line is deduced): hotpath = compile_assert_hotpath(common, hotpath, assert, 1);

4553

compile_hotpath(common, hotpath, cc, fallback);

never executed: }

4554 } -

4555 -

4556

executed (the execution status of this line is deduced): compile_hotpath(common, hotpath, cc, fallback);

4557

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4558

never executed: return ((void *)0);

4559 -

4560

if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)

partially evaluated: opcode == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4561 { -

4562

never evaluated: ((bracket_fallback*)fallback)->u.framesize < 0

4563 { -

4564

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

4565 /* TMP2 which is set here used by OP_KETRMAX below. */ -

4566

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);

never evaluated: ket == OP_KETRMAX

4567

never executed: sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (0));

4568

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);

never evaluated: ket == OP_KETRMIN

4569 { -

4570 /* Move the STR_PTR to the localptr. */ -

4571

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (0));

4572

stacksize = (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives) ? 2 : 1;

never executed: }

4573 } -

4574 else -

4575 { -

4576

never evaluated: ket == OP_KETRMIN

never evaluated: ket == OP_KETRMAX

never evaluated: has_alternatives

4577

OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (FALLBACK_AS(bracket_fallback)->u.framesize + stacksize) * sizeof(sljit_w));

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (23), (2), (0), ((0x100 | (11))), (localptr), (0x200), ((((bracket_fallback*)fallback)->u.framesize + stacksize) * sizeof(sljit_w)));

4578

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never evaluated: ket == OP_KETRMAX

4579 { -

4580 /* TMP2 which is set here used by OP_KETRMAX below. */ -

4581

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

never executed: }

never executed: }

4584 } -

4585 -

4586

if (ket != OP_KET || bra != OP_BRA)

executed (the execution status of this line is deduced): stacksize = 0;

4587

partially evaluated: ket != OP_KET

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: bra != OP_BRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4588

if (has_alternatives && opcode != OP_ONCE)

never executed: stacksize++;

4589

evaluated: has_alternatives

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

partially evaluated: opcode != OP_ONCE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-14

4590

executed: stacksize++;

Execution Count:1

4591 -

4592

if (stacksize > 0)

evaluated: stacksize > 0

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

4593

executed: allocate_stack(common, stacksize);

Execution Count:1

4594 -

4595

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);

executed (the execution status of this line is deduced): stacksize = 0;

4596

if (ket != OP_KET)

partially evaluated: ket != OP_KET

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4597 { -

4598

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (6), (0));

4599

never executed (the execution status of this line is deduced): stacksize++;

4600

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);

never executed: }

4601

else if (bra != OP_BRA)

partially evaluated: bra != OP_BRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4602 { -

4603

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4604

never executed (the execution status of this line is deduced): stacksize++;

4605

never executed: }

4606 -

4607

evaluated: has_alternatives

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

4608 { -

4609

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);

partially evaluated: opcode != OP_ONCE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

4610

executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

Execution Count:1

4611

if (ket != OP_KETRMAX)

partially evaluated: ket != OP_KETRMAX

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

4612

FALLBACK_AS(bracket_fallback)->althotpath = LABEL();

executed: ((bracket_fallback*)fallback)->althotpath = sljit_emit_label(compiler);

Execution Count:1

4613

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

executed: }

Execution Count:1

4614 -

4615 /* Must be after the hotpath label. */ -

4616

if (offset != 0)

partially evaluated: offset != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4617 { -

4618

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

4619

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (6), (0));

4620

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 0) * sizeof(sljit_w))), (1), (0));

4621

never executed: }

4622 -

4623

if (opcode == OP_ONCE || opcode >= OP_SBRA)

partially evaluated: ket == OP_KETRMAX

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4624 { -

4625

never evaluated: opcode == OP_ONCE

never evaluated: opcode >= OP_SBRA

4626 { -

4627

FALLBACK_AS(bracket_fallback)->althotpath = LABEL();

never evaluated: has_alternatives

4628

never executed: ((bracket_fallback*)fallback)->althotpath = sljit_emit_label(compiler);

4629 /* Checking zero-length iteration. */ -

4630

CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0, rmaxlabel);

never evaluated: opcode != OP_ONCE

4631

never executed: sljit_set_label(sljit_emit_cmp(compiler, (1), ((0x100 | (11))), (localptr), (6), (0)), (rmaxlabel));

4632 else -

4633 /* TMP2 must contain the starting STR_PTR. */ -

4634

CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmaxlabel);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (1), (3), (0), (6), (0)), (rmaxlabel));

4635 } -

4636 else -

4637

JUMPTO(SLJIT_JUMP, rmaxlabel);

never executed: sljit_set_label(sljit_emit_jump(compiler, (22)), (rmaxlabel));

4638

FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();

never executed (the execution status of this line is deduced): ((bracket_fallback*)fallback)->recursivehotpath = sljit_emit_label(compiler);

4639

never executed: }

4640 -

4641

FALLBACK_AS(bracket_fallback)->zerohotpath = LABEL();

partially evaluated: bra == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4642

never executed: ((bracket_fallback*)fallback)->zerohotpath = sljit_emit_label(compiler);

4643 -

4644

if (bra == OP_BRAMINZERO)

partially evaluated: bra == OP_BRAMINZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4645 { -

4646 /* This is a fallback path! (From the viewpoint of OP_BRAMINZERO) */ -

4647

JUMPTO(SLJIT_JUMP, ((braminzero_fallback*)parent)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((braminzero_fallback*)parent)->hotpath));

4648

if (braminzerojump != NULL)

never evaluated: braminzerojump != ((void *)0)

4649 { -

4650

JUMPHERE(braminzerojump);

never executed (the execution status of this line is deduced): sljit_set_label((braminzerojump), sljit_emit_label(compiler));

4651 /* We need to release the end pointer to perform the -

4652 fallback for the zero-length iteration. When -

4653 framesize is < 0, OP_ONCE will do the release itself. */ -

4654

if (opcode == OP_ONCE && FALLBACK_AS(bracket_fallback)->u.framesize >= 0)

never evaluated: opcode == OP_ONCE

never evaluated: ((bracket_fallback*)fallback)->u.framesize >= 0

4655 { -

4656

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

4657

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

4658

else if (ket == OP_KETRMIN && opcode != OP_ONCE)

never executed: }

4659

never evaluated: ket == OP_KETRMIN

never evaluated: opcode != OP_ONCE

4660

never executed: free_stack(common, 1);

4661 } -

4662 /* Continue to the normal fallback. */ -

4663

if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)

never executed: }

4664 -

4665

partially evaluated: ket != OP_KET

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

never evaluated: bra != OP_BRAMINZERO

partially evaluated: bra == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

4666

never executed: decrease_call_count(common);

4667 -

4668 /* Skip the other alternatives. */ -

4669

while (*cc == OP_ALT)

evaluated: *cc == OP_ALT

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:15

1-15

4670

executed: cc += (cc[1]);

Execution Count:1

4671

executed (the execution status of this line is deduced): cc += 1 + 1;

4672

executed: return cc;

Execution Count:15

4673 } -

4674 -

4675 static pcre_uchar *compile_bracketpos_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent) -

4676 { -

4677

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

4678

never executed (the execution status of this line is deduced): fallback_common *fallback;

4679

pcre_uchar *ccbegin = NULL;

never executed (the execution status of this line is deduced): pcre_uchar opcode;

4680

int localptr;

never executed (the execution status of this line is deduced): int localptr;

4681

int cbraprivptr = 0;

never executed (the execution status of this line is deduced): int cbraprivptr = 0;

4682

int framesize;

never executed (the execution status of this line is deduced): int framesize;

4683

int stacksize;

never executed (the execution status of this line is deduced): int stacksize;

4684

int offset = 0;

never executed (the execution status of this line is deduced): int offset = 0;

4685

BOOL zero = FALSE;

never executed (the execution status of this line is deduced): BOOL zero = 0;

4686

never executed (the execution status of this line is deduced): pcre_uchar *ccbegin = ((void *)0);

4687

int stack;

never executed (the execution status of this line is deduced): int stack;

4688

struct sljit_label *loop = NULL;

never executed (the execution status of this line is deduced): struct sljit_label *loop = ((void *)0);

4689

struct jump_list *emptymatch = NULL;

never executed (the execution status of this line is deduced): struct jump_list *emptymatch = ((void *)0);

4690 -

4691

PUSH_FALLBACK(sizeof(bracketpos_fallback), cc, NULL);

never executed: return ((void *)0);

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

4692

if (*cc == OP_BRAPOSZERO)

never evaluated: *cc == OP_BRAPOSZERO

4693 { -

4694

zero = TRUE;

never executed (the execution status of this line is deduced): zero = 1;

4695

never executed (the execution status of this line is deduced): cc++;

4696

never executed: }

4697 -

4698

localptr = PRIV_DATA(cc);

never executed (the execution status of this line is deduced): opcode = *cc;

4699

never executed (the execution status of this line is deduced): localptr = (common->localptrs[(cc) - common->start]);

4700

SLJIT_ASSERT(localptr != 0);

never executed: }

never evaluated: 0

4701

FALLBACK_AS(bracketpos_fallback)->localptr = localptr;

never executed (the execution status of this line is deduced): ((bracketpos_fallback*)fallback)->localptr = localptr;

4702 switch(opcode) -

4703 { -

4704 case OP_BRAPOS: -

4705 case OP_SBRAPOS: -

4706

ccbegin = cc + 1 + LINK_SIZE;

never executed (the execution status of this line is deduced): ccbegin = cc + 1 + 1;

4707

offset = GET2(cc, 1 + LINK_SIZE);

never executed: break;

4708 -

4709 case OP_CBRAPOS: -

4710 case OP_SCBRAPOS: -

4711

never executed (the execution status of this line is deduced): offset = cc[1 + 1];

4712

cbraprivptr = OVECTOR_PRIV(offset);

never executed (the execution status of this line is deduced): cbraprivptr = (common->cbraptr + (offset) * sizeof(sljit_w));

4713

offset <<= 1;

never executed (the execution status of this line is deduced): offset <<= 1;

4714

ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;

never executed (the execution status of this line is deduced): ccbegin = cc + 1 + 1 + 1;

4715

never executed: break;

4716 -

4717 default: -

4718

never executed: }

never evaluated: 0

4719

framesize = get_framesize(common, cc, FALSE);

never executed: break;

4720 } -

4721 -

4722

never executed (the execution status of this line is deduced): framesize = get_framesize(common, cc, 0);

4723

FALLBACK_AS(bracketpos_fallback)->framesize = framesize;

never executed (the execution status of this line is deduced): ((bracketpos_fallback*)fallback)->framesize = framesize;

4724

stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;

never evaluated: framesize < 0

4725 { -

4726

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4727

never evaluated: !zero

4728

FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;

never executed: stacksize++;

4729

never executed (the execution status of this line is deduced): ((bracketpos_fallback*)fallback)->stacksize = stacksize;

4730

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, stacksize);

4731

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (2), (0));

4732 -

4733

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4734 { -

4735

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))));

4736

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))));

4737

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (1), (0));

4738

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (3), (0));

4739

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed: }

4740 else -

4741

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

4742 -

4743

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 1);

never evaluated: !zero

4744

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize - 1) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

4745

stacksize = framesize + 1;

never executed: }

4746 else -

4747 { -

4748

never executed (the execution status of this line is deduced): stacksize = framesize + 1;

4749

never evaluated: !zero

4750

if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)

never executed: stacksize++;

4751

never evaluated: opcode == OP_BRAPOS

never evaluated: opcode == OP_SBRAPOS

4752

FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;

never executed: stacksize++;

4753

never executed (the execution status of this line is deduced): ((bracketpos_fallback*)fallback)->stacksize = stacksize;

4754

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): allocate_stack(common, stacksize);

4755 -

4756

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

4757

OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (3), (0), (2), (0), (0x200), (-((-(stacksize - 1) - 1) * (int)sizeof(sljit_w))));

4758

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (3), (0));

4759

stack = 0;

never executed (the execution status of this line is deduced): stack = 0;

4760

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);

never evaluated: !zero

4761 { -

4762

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

4763

stack++;

never executed (the execution status of this line is deduced): stack++;

4764

if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)

never executed: }

4765

never evaluated: opcode == OP_BRAPOS

never evaluated: opcode == OP_SBRAPOS

4766 { -

4767

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stack) - 1) * (int)sizeof(sljit_w))), (6), (0));

4768

stack++;

never executed (the execution status of this line is deduced): stack++;

4769

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);

never executed: }

4770

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stack) - 1) * (int)sizeof(sljit_w))), (1), (0));

4771

init_frame(common, cc, stacksize - 1, stacksize - framesize, FALSE);

never executed (the execution status of this line is deduced): init_frame(common, cc, stacksize - 1, stacksize - framesize, 0);

4772

never executed: }

4773 -

4774

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4775

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), (cbraprivptr), (6), (0));

4776 -

4777

while (*cc != OP_KETRPOS)

never executed (the execution status of this line is deduced): loop = sljit_emit_label(compiler);

4778

never evaluated: *cc != OP_KETRPOS

4779 { -

4780

fallback->top = NULL;

never executed (the execution status of this line is deduced): fallback->top = ((void *)0);

4781

fallback->topfallbacks = NULL;

never executed (the execution status of this line is deduced): fallback->topfallbacks = ((void *)0);

4782

compile_hotpath(common, ccbegin, cc, fallback);

never executed (the execution status of this line is deduced): cc += (cc[1]);

4783 -

4784

never executed (the execution status of this line is deduced): compile_hotpath(common, ccbegin, cc, fallback);

4785

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

4786

never executed: return ((void *)0);

4787 -

4788

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never evaluated: framesize < 0

4789 { -

4790

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

4791 -

4792

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4793 { -

4794

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (cbraprivptr));

4795

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (6), (0));

4796

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (cbraprivptr), (6), (0));

4797

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))), (1), (0));

4798

if (opcode == OP_SBRAPOS)

never executed: }

4799 else -

4800 { -

4801

never evaluated: opcode == OP_SBRAPOS

4802

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

4803

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

4804

if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)

never executed: }

4805 -

4806

never evaluated: opcode == OP_SBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4807

add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));

never executed: add_jump(compiler, &emptymatch, sljit_emit_cmp(compiler, (0), (1), (0), (6), (0)));

4808 -

4809

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);

never evaluated: !zero

4810

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize - 1) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4811

never executed: }

4812 else -

4813 { -

4814

OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, stacksize * sizeof(sljit_w));

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4815 { -

4816

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), ((0x100 | (11))), (localptr), (0x200), (stacksize * sizeof(sljit_w)));

4817

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (cbraprivptr));

4818

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (6), (0));

4819

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (cbraprivptr), (6), (0));

4820

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))), (1), (0));

4821

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed: }

4822 else -

4823 { -

4824

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (localptr));

4825

OP2(SLJIT_ADD, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (3), (0), (0x200), (stacksize * sizeof(sljit_w)));

4826

if (opcode == OP_SBRAPOS)

never evaluated: opcode == OP_SBRAPOS

4827

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w));

never executed: sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (3))), ((framesize + 1) * sizeof(sljit_w)));

4828

OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (3))), ((framesize + 1) * sizeof(sljit_w)), (6), (0));

4829

if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)

never executed: }

4830 -

4831

never evaluated: opcode == OP_SBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4832

add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));

never executed: add_jump(compiler, &emptymatch, sljit_emit_cmp(compiler, (0), (1), (0), (6), (0)));

4833 -

4834

never evaluated: !zero

4835 { -

4836

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);

never evaluated: framesize < 0

4837

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize - 1) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4838 else -

4839

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

4840 } -

4841

JUMPTO(SLJIT_JUMP, loop);

never executed: }

4842

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (loop));

4843

flush_stubs(common);

never executed (the execution status of this line is deduced): flush_stubs(common);

4844 -

4845

compile_fallbackpath(common, fallback->top);

never executed (the execution status of this line is deduced): compile_fallbackpath(common, fallback->top);

4846

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

4847

set_jumps(fallback->topfallbacks, LABEL());

never executed: return ((void *)0);

4848

never executed (the execution status of this line is deduced): set_jumps(fallback->topfallbacks, sljit_emit_label(compiler));

4849 -

4850

never evaluated: framesize < 0

4851 { -

4852

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4853

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), (cbraprivptr));

4854 else -

4855

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

4856 } -

4857 else -

4858 { -

4859

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never evaluated: opcode == OP_CBRAPOS

never evaluated: opcode == OP_SCBRAPOS

4860 { -

4861 /* Last alternative. */ -

4862

if (*cc == OP_KETRPOS)

never evaluated: *cc == OP_KETRPOS

4863

never executed: sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (localptr));

4864

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), (cbraprivptr));

4865

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed: }

4866 else -

4867 { -

4868

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), (localptr));

4869

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (3))), ((framesize + 1) * sizeof(sljit_w)));

4870

never executed: }

4871 } -

4872 -

4873

if (*cc == OP_KETRPOS)

never evaluated: *cc == OP_KETRPOS

4874

ccbegin = cc + 1 + LINK_SIZE;

never executed: break;

4875

never executed (the execution status of this line is deduced): ccbegin = cc + 1 + 1;

4876

fallback->topfallbacks = NULL;

never executed: }

4877 -

4878

never executed (the execution status of this line is deduced): fallback->topfallbacks = ((void *)0);

4879

never evaluated: !zero

4880 { -

4881

add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));

never evaluated: framesize < 0

4882

never executed:

add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (1), ((0x100 | (2))), (((-(stacksize - 1) - 1) * (int)sizeof(sljit_w))), (0x200), (0)));

4883 else /* TMP2 is set to [localptr] above. */ -

4884

add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0));

never executed:

add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (1), ((0x100 | (3))), ((stacksize - 1) * sizeof(sljit_w)), (0x200), (0)));

4885 } -

4886 -

4887 /* None of them matched. */ -

4888

set_jumps(emptymatch, LABEL());

never executed (the execution status of this line is deduced): set_jumps(emptymatch, sljit_emit_label(compiler));

4889

never executed (the execution status of this line is deduced): decrease_call_count(common);

4890

if (*opcode >= OP_STAR && *opcode <= OP_POSUPTO)

never executed: return cc + 1 + 1;

4891 } -

4892 -

4893 static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, int *arg1, int *arg2, pcre_uchar **end) -

4894 { -

4895

int class_len;

executed (the execution status of this line is deduced): int class_len;

4896 -

4897

*opcode = *cc;

executed (the execution status of this line is deduced): *opcode = *cc;

4898

partially evaluated: *opcode >= OP_STAR

TRUE	FALSE
yes Evaluation Count:16	no Evaluation Count:0

evaluated: *opcode <= OP_POSUPTO

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:12

0-16

4899 { -

4900

executed (the execution status of this line is deduced): cc++;

4901

*type = OP_CHAR;

executed (the execution status of this line is deduced): *type = OP_CHAR;

4902

else if (*opcode >= OP_STARI && *opcode <= OP_POSUPTOI)

executed: }

Execution Count:4

4903

partially evaluated: *opcode >= OP_STARI

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

partially evaluated: *opcode <= OP_POSUPTOI

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12

0-12

4904 { -

4905

*opcode -= OP_STARI - OP_STAR;

never executed (the execution status of this line is deduced): cc++;

4906

*type = OP_CHARI;

never executed (the execution status of this line is deduced): *type = OP_CHARI;

4907

never executed (the execution status of this line is deduced): *opcode -= OP_STARI - OP_STAR;

4908

else if (*opcode >= OP_NOTSTAR && *opcode <= OP_NOTPOSUPTO)

never executed: }

4909

partially evaluated: *opcode >= OP_NOTSTAR

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

partially evaluated: *opcode <= OP_NOTPOSUPTO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12

0-12

4910 { -

4911

*opcode -= OP_NOTSTAR - OP_STAR;

never executed (the execution status of this line is deduced): cc++;

4912

*type = OP_NOT;

never executed (the execution status of this line is deduced): *type = OP_NOT;

4913

never executed (the execution status of this line is deduced): *opcode -= OP_NOTSTAR - OP_STAR;

4914

else if (*opcode >= OP_NOTSTARI && *opcode <= OP_NOTPOSUPTOI)

never executed: }

4915

partially evaluated: *opcode >= OP_NOTSTARI

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

partially evaluated: *opcode <= OP_NOTPOSUPTOI

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12

0-12

4916 { -

4917

*opcode -= OP_NOTSTARI - OP_STAR;

never executed (the execution status of this line is deduced): cc++;

4918

*type = OP_NOTI;

never executed (the execution status of this line is deduced): *type = OP_NOTI;

4919

never executed (the execution status of this line is deduced): *opcode -= OP_NOTSTARI - OP_STAR;

4920

else if (*opcode >= OP_TYPESTAR && *opcode <= OP_TYPEPOSUPTO)

never executed: }

4921

partially evaluated: *opcode >= OP_TYPESTAR

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

evaluated: *opcode <= OP_TYPEPOSUPTO

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:2

0-12

4922 { -

4923

*opcode -= OP_TYPESTAR - OP_STAR;

executed (the execution status of this line is deduced): cc++;

4924

executed (the execution status of this line is deduced): *opcode -= OP_TYPESTAR - OP_STAR;

4925

*type = 0;

executed (the execution status of this line is deduced): *type = 0;

4926

SLJIT_ASSERT(*opcode >= OP_CLASS || *opcode <= OP_XCLASS);

executed: }

Execution Count:10

4927 else -

4928 { -

4929

executed: }

Execution Count:2

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

4930

*type = *opcode;

executed (the execution status of this line is deduced): *type = *opcode;

4931

class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);

executed (the execution status of this line is deduced): cc++;

4932

partially evaluated: (*type < OP_XCLASS)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

4933

*opcode = cc[class_len - 1];

executed (the execution status of this line is deduced): *opcode = cc[class_len - 1];

4934

if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)

partially evaluated: *opcode >= OP_CRSTAR

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

partially evaluated: *opcode <= OP_CRMINQUERY

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

0-2

4935 { -

4936

*opcode -= OP_CRSTAR - OP_STAR;

executed (the execution status of this line is deduced): *opcode -= OP_CRSTAR - OP_STAR;

4937

evaluated: end != ((void *)0)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:1

4938

*end = cc + class_len;

executed: *end = cc + class_len;

Execution Count:1

4939

SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE);

executed: }

Execution Count:2

4940 else -

4941 { -

4942

never executed: }

never evaluated: 0

4943

*arg1 = GET2(cc, (class_len + IMM2_SIZE));

never executed (the execution status of this line is deduced): *arg1 = cc[(class_len + 1)];

4944

*arg2 = GET2(cc, class_len);

never executed (the execution status of this line is deduced): *arg2 = cc[class_len];

4945 -

4946

if (*arg2 == 0)

never evaluated: *arg2 == 0

4947 { -

4948

SLJIT_ASSERT(*arg1 != 0);

never executed: }

never evaluated: 0

4949

*opcode = (*opcode == OP_CRRANGE) ? OP_UPTO : OP_MINUPTO;

never evaluated: (*opcode == OP_CRRANGE)

never executed: }

never evaluated: *arg1 == *arg2

4952

*opcode = OP_EXACT;

never executed: *opcode = OP_EXACT;

4953 -

4954

*end = cc + class_len + 2 * IMM2_SIZE;

never evaluated: end != ((void *)0)

4955

never executed: *end = cc + class_len + 2 * 1;

never executed: }

executed: return cc;

Execution Count:2

4958 } -

4959 -

4960

if (*opcode == OP_UPTO || *opcode == OP_MINUPTO || *opcode == OP_EXACT || *opcode == OP_POSUPTO)

partially evaluated: *opcode == OP_UPTO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:14

partially evaluated: *opcode == OP_MINUPTO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:14

partially evaluated: *opcode == OP_EXACT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:14

partially evaluated: *opcode == OP_POSUPTO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:14

0-14

4961 { -

4962

*arg1 = GET2(cc, 0);

never executed (the execution status of this line is deduced): *arg1 = cc[0];

4963

cc += IMM2_SIZE;

never executed (the execution status of this line is deduced): cc += 1;

4964

never executed: }

4965 -

4966

if (*type == 0)

evaluated: *type == 0

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:4

4-10

4967 { -

4968

*type = *cc;

executed (the execution status of this line is deduced): *type = *cc;

4969

*end = next_opcode(common, cc);

evaluated: end != ((void *)0)

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:5

4970

executed: *end = next_opcode(common, cc);

Execution Count:5

4971

executed (the execution status of this line is deduced): cc++;

4972

executed: return cc;

Execution Count:10

4973 } -

4974 -

4975

if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);

evaluated: end != ((void *)0)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:2

4976 { -

4977

*end = cc + 1;

executed (the execution status of this line is deduced): *end = cc + 1;

4978 #ifdef SUPPORT_UTF -

4979

never executed: *end += 1;

partially evaluated: common->utf

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

partially evaluated: (((*cc) & 0xfc00) == 0xd800)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:2

0-2

4980 #endif -

4981

executed: }

Execution Count:2

4982

executed: return cc;

Execution Count:4

4983 } -

4984 -

4985 static pcre_uchar *compile_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent) -

4986 { -

4987

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

4988

executed (the execution status of this line is deduced): fallback_common *fallback;

4989

executed (the execution status of this line is deduced): pcre_uchar opcode;

4990

int arg1 = -1, arg2 = -1;

executed (the execution status of this line is deduced): pcre_uchar type;

4991

executed (the execution status of this line is deduced): int arg1 = -1, arg2 = -1;

4992

pcre_uchar* end;

executed (the execution status of this line is deduced): pcre_uchar* end;

4993

jump_list *nomatch = NULL;

executed (the execution status of this line is deduced): jump_list *nomatch = ((void *)0);

4994

executed (the execution status of this line is deduced): struct sljit_jump *jump = ((void *)0);

4995

PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);

executed (the execution status of this line is deduced): struct sljit_label *label;

4996 -

4997

never executed: return ((void *)0);

executed: }

Execution Count:8

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

4998 -

4999

cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);

executed (the execution status of this line is deduced): cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);

5000 -

5001 switch(opcode) -

5002 { -

5003 case OP_STAR: -

5004 case OP_PLUS: -

5005 case OP_UPTO: -

5006 case OP_CRRANGE: -

5007

if (type == OP_ANYNL || type == OP_EXTUNI)

partially evaluated: type == OP_ANYNL

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

partially evaluated: type == OP_EXTUNI

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

5008 { -

5009

if (opcode == OP_STAR || opcode == OP_UPTO)

never evaluated: opcode == OP_STAR

never evaluated: opcode == OP_UPTO

5010 { -

5011

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 2);

5012

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5013

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5014

never executed: }

5015 else -

5016 { -

5017

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

5018

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5019

if (opcode == OP_UPTO || opcode == OP_CRRANGE)

never executed: }

5020

never evaluated: opcode == OP_UPTO

never evaluated: opcode == OP_CRRANGE

5021

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (0));

5022 -

5023

compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

5024

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);

5025

if (opcode == OP_UPTO || opcode == OP_CRRANGE)

never evaluated: opcode == OP_UPTO

never evaluated: opcode == OP_CRRANGE

5026 { -

5027

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

5028

if (opcode == OP_CRRANGE && arg2 > 0)

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

5029

never evaluated: opcode == OP_CRRANGE

never evaluated: arg2 > 0

5030

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2, label);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (arg2)), (label));

5031

if (opcode == OP_UPTO || (opcode == OP_CRRANGE && arg1 > 0))

never evaluated: opcode == OP_UPTO

never evaluated: opcode == OP_CRRANGE

never evaluated: arg1 > 0

5032

jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, arg1);

never executed: jump = sljit_emit_cmp(compiler, (3), (1), (0), (0x200), (arg1));

5033

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (1), (0));

5034

never executed: }

5035 -

5036

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

5037

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5038

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (label));

5039

never evaluated: jump != ((void *)0)

5040

never executed: sljit_set_label((jump), sljit_emit_label(compiler));

5041

never executed: }

5042 else -

5043 { -

5044

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

executed (the execution status of this line is deduced): allocate_stack(common, 2);

5045

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5046

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

5047

compile_char1_hotpath(common, type, cc, &nomatch);

executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

5048

executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &nomatch);

5049

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5050

if (opcode <= OP_PLUS || (opcode == OP_CRRANGE && arg1 == 0))

partially evaluated: opcode <= OP_PLUS

TRUE	FALSE
yes Evaluation Count:8	no Evaluation Count:0

never evaluated: opcode == OP_CRRANGE

never evaluated: arg1 == 0

0-8

5051 { -

5052

OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);

executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (23), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

5053

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (label));

5054

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

executed: }

Execution Count:8

5055 else -

5056 { -

5057

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

5058

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

5059

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (1), (0));

5060

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (arg1 + 1)), (label));

5061

set_jumps(nomatch, LABEL());

never executed: }

5062

executed (the execution status of this line is deduced): set_jumps(nomatch, sljit_emit_label(compiler));

5063

if (opcode == OP_PLUS || opcode == OP_CRRANGE)

partially evaluated: opcode == OP_PLUS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

partially evaluated: opcode == OP_CRRANGE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

5064

add_jump(compiler, &fallback->topfallbacks,

never executed:

add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (2), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (opcode == OP_PLUS ? 2 : arg2 + 1)));

5065

CMP(SLJIT_C_LESS, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, opcode == OP_PLUS ? 2 : arg2 + 1));

never executed:

add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (2), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (opcode == OP_PLUS ? 2 : arg2 + 1)));

5066

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5067

executed: }

Execution Count:8

5068

executed (the execution status of this line is deduced): ((iterator_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

5069

executed: break;

Execution Count:8

5070 -

5071 case OP_MINSTAR: -

5072 case OP_MINPLUS: -

5073

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

5074

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5075

if (opcode == OP_MINPLUS)

never evaluated: opcode == OP_MINPLUS

5076

add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));

never executed: add_jump(compiler, &fallback->topfallbacks, sljit_emit_jump(compiler, (22)));

5077

never executed (the execution status of this line is deduced): ((iterator_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

5078

never executed: break;

5079 -

5080 case OP_MINUPTO: -

5081 case OP_CRMINRANGE: -

5082

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 2);

5083

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5084

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

5085

if (opcode == OP_CRMINRANGE)

never evaluated: opcode == OP_CRMINRANGE

5086

add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));

never executed: add_jump(compiler, &fallback->topfallbacks, sljit_emit_jump(compiler, (22)));

5087

never executed (the execution status of this line is deduced): ((iterator_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

5088

never executed: break;

5089 -

5090 case OP_QUERY: -

5091 case OP_MINQUERY: -

5092

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

5093

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5094

if (opcode == OP_QUERY)

never evaluated: opcode == OP_QUERY

5095

compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);

never executed: compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);

5096

never executed (the execution status of this line is deduced): ((iterator_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

5097

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);

never executed: break;

5098 -

5099 case OP_EXACT: -

5100

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (1));

5101

compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

5102

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);

5103

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

5104

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

5105

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (1), (0));

5106

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (arg1 + 1)), (label));

5107

if (opcode != OP_POSSTAR)

never executed: break;

5108 -

5109 case OP_POSSTAR: -

5110 case OP_POSPLUS: -

5111 case OP_POSUPTO: -

5112

never evaluated: opcode != OP_POSSTAR

5113

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (1));

5114

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((3 * sizeof(sljit_w))), (6), (0));

5115

compile_char1_hotpath(common, type, cc, &nomatch);

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

5116

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &nomatch);

5117

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((3 * sizeof(sljit_w))), (6), (0));

5118

if (opcode != OP_POSUPTO)

never evaluated: opcode != OP_POSUPTO

5119 { -

5120

if (opcode == OP_POSPLUS)

never evaluated: opcode == OP_POSPLUS

5121

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (2));

5122

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (label));

5123

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);

never executed: }

5124 else -

5125 { -

5126

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), ((2 * sizeof(sljit_w))));

5127

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

5128

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (1), (0));

5129

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (arg1 + 1)), (label));

5130

set_jumps(nomatch, LABEL());

never executed: }

5131

never executed (the execution status of this line is deduced): set_jumps(nomatch, sljit_emit_label(compiler));

5132

if (opcode == OP_POSPLUS)

never evaluated: opcode == OP_POSPLUS

5133

add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_LESS, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2));

never executed:

add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (2), ((0x100 | (11))), ((2 * sizeof(sljit_w))), (0x200), (2)));

5134

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), ((3 * sizeof(sljit_w))));

5135

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);

never executed: break;

5136 -

5137 case OP_POSQUERY: -

5138

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((3 * sizeof(sljit_w))), (6), (0));

5139

compile_char1_hotpath(common, type, cc, &nomatch);

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &nomatch);

5140

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((3 * sizeof(sljit_w))), (6), (0));

5141

set_jumps(nomatch, LABEL());

never executed (the execution status of this line is deduced): set_jumps(nomatch, sljit_emit_label(compiler));

5142

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), ((3 * sizeof(sljit_w))));

5143

never executed: break;

5144 -

5145 default: -

5146

never executed: }

never evaluated: 0

5147

never executed: break;

5148 } -

5149 -

5150

executed (the execution status of this line is deduced): decrease_call_count(common);

5151

return end;

executed: return end;

Execution Count:8

5152 } -

5153 -

5154 static SLJIT_INLINE pcre_uchar *compile_fail_accept_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent) -

5155 { -

5156

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5157

PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);

never executed (the execution status of this line is deduced): fallback_common *fallback;

5158 -

5159

never executed: return ((void *)0);

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

5160 -

5161

if (*cc == OP_FAIL)

never evaluated: *cc == OP_FAIL

5162 { -

5163

add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));

never executed (the execution status of this line is deduced): add_jump(compiler, &fallback->topfallbacks, sljit_emit_jump(compiler, (22)));

5164

if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL)

never executed: return cc + 1;

5165 } -

5166 -

5167

never evaluated: *cc == OP_ASSERT_ACCEPT

never evaluated: common->currententry != ((void *)0)

5168 { -

5169 /* No need to check notempty conditions. */ -

5170

add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));

never evaluated: common->acceptlabel == ((void *)0)

5171

never executed: add_jump(compiler, &common->accept, sljit_emit_jump(compiler, (22)));

5172 else -

5173

JUMPTO(SLJIT_JUMP, common->acceptlabel);

never executed: sljit_set_label(sljit_emit_jump(compiler, (22)), (common->acceptlabel));

5174

never executed: return cc + 1;

5175 } -

5176 -

5177

add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0)));

never evaluated: common->acceptlabel == ((void *)0)

5178

never executed:

add_jump(compiler, &common->accept, sljit_emit_cmp(compiler, (1), (6), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w)))));

5179 else -

5180

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->acceptlabel);

never executed:

sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w)))), (common->acceptlabel));

5181

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

5182

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->notempty) - 0x10)));

5183

add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never executed (the execution status of this line is deduced): add_jump(compiler, &fallback->topfallbacks, sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)));

5184

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));

never executed (the execution status of this line is deduced):

sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->notempty_atstart) - 0x10)));

5185

add_jump(compiler, &common->accept, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0));

never evaluated: common->acceptlabel == ((void *)0)

5186

never executed: add_jump(compiler, &common->accept, sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (0)));

5187 else -

5188

CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->acceptlabel);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (0)), (common->acceptlabel));

5189

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->str) - 0x10)));

5190

add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0));

never evaluated: common->acceptlabel == ((void *)0)

5191

never executed: add_jump(compiler, &common->accept, sljit_emit_cmp(compiler, (1), (3), (0), (6), (0)));

5192 else -

5193

CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->acceptlabel);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (1), (3), (0), (6), (0)), (common->acceptlabel));

5194

add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));

never executed (the execution status of this line is deduced): add_jump(compiler, &fallback->topfallbacks, sljit_emit_jump(compiler, (22)));

5195

never executed: return cc + 1;

5196 } -

5197 -

5198 static SLJIT_INLINE pcre_uchar *compile_close_hotpath(compiler_common *common, pcre_uchar *cc) -

5199 { -

5200

int offset = GET2(cc, 1);

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5201

never executed (the execution status of this line is deduced): int offset = cc[1];

5202 -

5203 /* Data will be discarded anyway... */ -

5204

if (common->currententry != NULL)

never evaluated: common->currententry != ((void *)0)

5205

return cc + 1 + IMM2_SIZE;

never executed: return cc + 1 + 1;

5206 -

5207

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR_PRIV(offset));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), ((common->cbraptr + (offset) * sizeof(sljit_w))));

5208

offset <<= 1;

never executed (the execution status of this line is deduced): offset <<= 1;

5209

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (6), (0));

5210

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))), (1), (0));

5211

return cc + 1 + IMM2_SIZE;

never executed: return cc + 1 + 1;

5212 } -

5213 -

5214 static void compile_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, fallback_common *parent) -

5215 { -

5216

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5217

executed (the execution status of this line is deduced): fallback_common *fallback;

5218 -

5219

cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);

evaluated: cc < ccend

TRUE	FALSE
yes Evaluation Count:31	yes Evaluation Count:31

5220 { -

5221 switch(*cc) -

5222 { -

5223 case OP_SOD: -

5224 case OP_SOM: -

5225 case OP_NOT_WORD_BOUNDARY: -

5226 case OP_WORD_BOUNDARY: -

5227 case OP_NOT_DIGIT: -

5228 case OP_DIGIT: -

5229 case OP_NOT_WHITESPACE: -

5230 case OP_WHITESPACE: -

5231 case OP_NOT_WORDCHAR: -

5232 case OP_WORDCHAR: -

5233 case OP_ANY: -

5234 case OP_ALLANY: -

5235 case OP_ANYBYTE: -

5236 case OP_NOTPROP: -

5237 case OP_PROP: -

5238 case OP_ANYNL: -

5239 case OP_NOT_HSPACE: -

5240 case OP_HSPACE: -

5241 case OP_NOT_VSPACE: -

5242 case OP_VSPACE: -

5243 case OP_EXTUNI: -

5244 case OP_EODN: -

5245 case OP_EOD: -

5246 case OP_CIRC: -

5247 case OP_CIRCM: -

5248 case OP_DOLL: -

5249 case OP_DOLLM: -

5250 case OP_NOT: -

5251 case OP_NOTI: -

5252 case OP_REVERSE: -

5253

executed (the execution status of this line is deduced):

 cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != ((void *)0) ? &parent->top->nextfallbacks : &parent->topfallbacks);

5254

PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);

executed: break;

Execution Count:1

5255 -

5256 case OP_SET_SOM: -

5257

never executed: return;

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

5258

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

5259

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))));

5260

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), (6), (0));

5261

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (1), (0));

5262

never executed (the execution status of this line is deduced): cc++;

5263

cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);

never executed: break;

5264 -

5265 case OP_CHAR: -

5266 case OP_CHARI: -

5267

executed (the execution status of this line is deduced):

 cc = compile_charn_hotpath(common, cc, ccend, parent->top != ((void *)0) ? &parent->top->nextfallbacks : &parent->topfallbacks);

5268

cc = compile_iterator_hotpath(common, cc, parent);

executed: break;

Execution Count:7

5269 -

5270 case OP_STAR: -

5271 case OP_MINSTAR: -

5272 case OP_PLUS: -

5273 case OP_MINPLUS: -

5274 case OP_QUERY: -

5275 case OP_MINQUERY: -

5276 case OP_UPTO: -

5277 case OP_MINUPTO: -

5278 case OP_EXACT: -

5279 case OP_POSSTAR: -

5280 case OP_POSPLUS: -

5281 case OP_POSQUERY: -

5282 case OP_POSUPTO: -

5283 case OP_STARI: -

5284 case OP_MINSTARI: -

5285 case OP_PLUSI: -

5286 case OP_MINPLUSI: -

5287 case OP_QUERYI: -

5288 case OP_MINQUERYI: -

5289 case OP_UPTOI: -

5290 case OP_MINUPTOI: -

5291 case OP_EXACTI: -

5292 case OP_POSSTARI: -

5293 case OP_POSPLUSI: -

5294 case OP_POSQUERYI: -

5295 case OP_POSUPTOI: -

5296 case OP_NOTSTAR: -

5297 case OP_NOTMINSTAR: -

5298 case OP_NOTPLUS: -

5299 case OP_NOTMINPLUS: -

5300 case OP_NOTQUERY: -

5301 case OP_NOTMINQUERY: -

5302 case OP_NOTUPTO: -

5303 case OP_NOTMINUPTO: -

5304 case OP_NOTEXACT: -

5305 case OP_NOTPOSSTAR: -

5306 case OP_NOTPOSPLUS: -

5307 case OP_NOTPOSQUERY: -

5308 case OP_NOTPOSUPTO: -

5309 case OP_NOTSTARI: -

5310 case OP_NOTMINSTARI: -

5311 case OP_NOTPLUSI: -

5312 case OP_NOTMINPLUSI: -

5313 case OP_NOTQUERYI: -

5314 case OP_NOTMINQUERYI: -

5315 case OP_NOTUPTOI: -

5316 case OP_NOTMINUPTOI: -

5317 case OP_NOTEXACTI: -

5318 case OP_NOTPOSSTARI: -

5319 case OP_NOTPOSPLUSI: -

5320 case OP_NOTPOSQUERYI: -

5321 case OP_NOTPOSUPTOI: -

5322 case OP_TYPESTAR: -

5323 case OP_TYPEMINSTAR: -

5324 case OP_TYPEPLUS: -

5325 case OP_TYPEMINPLUS: -

5326 case OP_TYPEQUERY: -

5327 case OP_TYPEMINQUERY: -

5328 case OP_TYPEUPTO: -

5329 case OP_TYPEMINUPTO: -

5330 case OP_TYPEEXACT: -

5331 case OP_TYPEPOSSTAR: -

5332 case OP_TYPEPOSPLUS: -

5333 case OP_TYPEPOSQUERY: -

5334 case OP_TYPEPOSUPTO: -

5335

executed (the execution status of this line is deduced): cc = compile_iterator_hotpath(common, cc, parent);

5336

if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRMINRANGE)

executed: break;

Execution Count:7

5337 -

5338 case OP_CLASS: -

5339 case OP_NCLASS: -

5340

never evaluated: cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR

never evaluated: cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRMINRANGE

5341

cc = compile_iterator_hotpath(common, cc, parent);

never executed: cc = compile_iterator_hotpath(common, cc, parent);

5342 else -

5343

cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);

never executed:

cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != ((void *)0) ? &parent->top->nextfallbacks : &parent->topfallbacks);

5344

if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRMINRANGE)

never executed: break;

5345 -

5346 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 -

5347 case OP_XCLASS: -

5348

partially evaluated: *(cc + (cc[1])) >= OP_CRSTAR

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: *(cc + (cc[1])) <= OP_CRMINRANGE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5349

cc = compile_iterator_hotpath(common, cc, parent);

executed: cc = compile_iterator_hotpath(common, cc, parent);

Execution Count:1

5350 else -

5351

cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);

never executed:

cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != ((void *)0) ? &parent->top->nextfallbacks : &parent->topfallbacks);

5352

if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRMINRANGE)

executed: break;

Execution Count:1

5353 #endif -

5354 -

5355 case OP_REF: -

5356 case OP_REFI: -

5357

never evaluated: cc[1 + 1] >= OP_CRSTAR

never evaluated: cc[1 + 1] <= OP_CRMINRANGE

5358

cc = compile_ref_iterator_hotpath(common, cc, parent);

never executed: cc = compile_ref_iterator_hotpath(common, cc, parent);

5359 else -

5360

cc = compile_ref_hotpath(common, cc, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks, TRUE, FALSE);

never executed:

cc = compile_ref_hotpath(common, cc, parent->top != ((void *)0) ? &parent->top->nextfallbacks : &parent->topfallbacks, 1, 0);

5361

cc = compile_recurse_hotpath(common, cc, parent);

never executed: break;

5362 -

5363 case OP_RECURSE: -

5364

never executed (the execution status of this line is deduced): cc = compile_recurse_hotpath(common, cc, parent);

5365

PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);

never executed: break;

5366 -

5367 case OP_ASSERT: -

5368 case OP_ASSERT_NOT: -

5369 case OP_ASSERTBACK: -

5370 case OP_ASSERTBACK_NOT: -

5371

never executed: return;

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

5372

cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);

never executed (the execution status of this line is deduced): cc = compile_assert_hotpath(common, cc, ((assert_fallback*)fallback), 0);

5373

PUSH_FALLBACK_NOVALUE(sizeof(braminzero_fallback), cc);

never executed: break;

5374 -

5375 case OP_BRAMINZERO: -

5376

never executed: return;

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

5377

cc = bracketend(cc + 1);

never executed (the execution status of this line is deduced): cc = bracketend(cc + 1);

5378

if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)

never evaluated: *(cc - 1 - 1) != OP_KETRMIN

5379 { -

5380

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 1);

5381

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5382

never executed: }

5383 else -

5384 { -

5385

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): allocate_stack(common, 2);

5386

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5387

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (6), (0));

5388

FALLBACK_AS(braminzero_fallback)->hotpath = LABEL();

never executed: }

5389

never executed (the execution status of this line is deduced): ((braminzero_fallback*)fallback)->hotpath = sljit_emit_label(compiler);

5390

if (cc[1] > OP_ASSERTBACK_NOT)

never evaluated: cc[1] > OP_ASSERTBACK_NOT

5391

never executed: decrease_call_count(common);

5392

cc = compile_bracket_hotpath(common, cc, parent);

never executed: break;

5393 -

5394 case OP_ONCE: -

5395 case OP_ONCE_NC: -

5396 case OP_BRA: -

5397 case OP_CBRA: -

5398 case OP_COND: -

5399 case OP_SBRA: -

5400 case OP_SCBRA: -

5401 case OP_SCOND: -

5402

executed (the execution status of this line is deduced): cc = compile_bracket_hotpath(common, cc, parent);

5403

if (cc[1] > OP_ASSERTBACK_NOT)

executed: break;

Execution Count:15

5404 -

5405 case OP_BRAZERO: -

5406

never evaluated: cc[1] > OP_ASSERTBACK_NOT

5407

cc = compile_bracket_hotpath(common, cc, parent);

never executed: cc = compile_bracket_hotpath(common, cc, parent);

5408 else -

5409 { -

5410

PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);

never executed: return;

never executed: }

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

never evaluated: 0

5411

cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);

never executed (the execution status of this line is deduced): cc = compile_assert_hotpath(common, cc, ((assert_fallback*)fallback), 0);

never executed: }

never executed: break;

5414 -

5415 case OP_BRAPOS: -

5416 case OP_CBRAPOS: -

5417 case OP_SBRAPOS: -

5418 case OP_SCBRAPOS: -

5419 case OP_BRAPOSZERO: -

5420

cc = compile_bracketpos_hotpath(common, cc, parent);

never executed (the execution status of this line is deduced): cc = compile_bracketpos_hotpath(common, cc, parent);

5421

cc = compile_fail_accept_hotpath(common, cc, parent);

never executed: break;

5422 -

5423 case OP_FAIL: -

5424 case OP_ACCEPT: -

5425 case OP_ASSERT_ACCEPT: -

5426

never executed (the execution status of this line is deduced): cc = compile_fail_accept_hotpath(common, cc, parent);

5427

cc = compile_close_hotpath(common, cc);

never executed: break;

5428 -

5429 case OP_CLOSE: -

5430

never executed (the execution status of this line is deduced): cc = compile_close_hotpath(common, cc);

5431

never executed: break;

5432 -

5433 case OP_SKIPZERO: -

5434

cc = bracketend(cc + 1);

never executed (the execution status of this line is deduced): cc = bracketend(cc + 1);

5435

never executed: break;

5436 -

5437 default: -

5438

never executed: }

never evaluated: 0

5439

never executed: return;

5440 } -

5441

if (cc == NULL)

partially evaluated: cc == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:31

0-31

5442

never executed: return;

5443

SLJIT_ASSERT(cc == ccend);

executed: }

Execution Count:31

5444

executed: }

Execution Count:31

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:31

0-31

5445

executed: }

Execution Count:31

5446 -

5447 #undef PUSH_FALLBACK -

5448 #undef PUSH_FALLBACK_NOVALUE -

5449 #undef FALLBACK_AS -

5450 -

5451 #define COMPILE_FALLBACKPATH(current) \ -

5452 do \ -

5453 { \ -

5454 compile_fallbackpath(common, (current)); \ -

5455 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \ -

5456 return; \ -

5457 } \ -

5458 while (0) -

5459 -

5460 #define CURRENT_AS(type) ((type*)current) -

5461 -

5462 static void compile_iterator_fallbackpath(compiler_common *common, struct fallback_common *current) -

5463 { -

5464

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5465

executed (the execution status of this line is deduced): pcre_uchar *cc = current->cc;

5466

executed (the execution status of this line is deduced): pcre_uchar opcode;

5467

int arg1 = -1, arg2 = -1;

executed (the execution status of this line is deduced): pcre_uchar type;

5468

executed (the execution status of this line is deduced): int arg1 = -1, arg2 = -1;

5469

struct sljit_label *label = NULL;

executed (the execution status of this line is deduced): struct sljit_label *label = ((void *)0);

5470

cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, NULL);

executed (the execution status of this line is deduced): struct sljit_jump *jump = ((void *)0);

5471 -

5472

executed (the execution status of this line is deduced): cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, ((void *)0));

5473 -

5474 switch(opcode) -

5475 { -

5476 case OP_STAR: -

5477 case OP_PLUS: -

5478 case OP_UPTO: -

5479 case OP_CRRANGE: -

5480

if (type == OP_ANYNL || type == OP_EXTUNI)

partially evaluated: type == OP_ANYNL

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

partially evaluated: type == OP_EXTUNI

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

5481 { -

5482

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5483

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5484

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): free_stack(common, 1);

5485

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((iterator_fallback*)current)->hotpath));

5486

if (opcode == OP_STAR || opcode == OP_UPTO)

never executed: }

5487 else -

5488 { -

5489

partially evaluated: opcode == OP_STAR

TRUE	FALSE
yes Evaluation Count:8	no Evaluation Count:0

never evaluated: opcode == OP_UPTO

0-8

5490

arg2 = 0;

executed: arg2 = 0;

Execution Count:8

5491

else if (opcode == OP_PLUS)

never evaluated: opcode == OP_PLUS

5492

arg2 = 1;

never executed: arg2 = 1;

5493

jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, arg2 + 1);

executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (5), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (arg2 + 1));

5494

OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);

executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (25), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (0x200), (1));

5495

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5496

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

executed (the execution status of this line is deduced): skip_char_back(common);

5497

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5498

JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((iterator_fallback*)current)->hotpath));

5499

if (opcode == OP_PLUS || opcode == OP_CRRANGE)

partially evaluated: opcode == OP_PLUS

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

partially evaluated: opcode == OP_CRRANGE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

5500

never executed: set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5501

executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

5502

executed (the execution status of this line is deduced): free_stack(common, 2);

5503

executed: }

Execution Count:8

5504

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

executed: break;

Execution Count:8

5505 -

5506 case OP_MINSTAR: -

5507 case OP_MINPLUS: -

5508

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5509

if (opcode == OP_MINPLUS)

never evaluated: opcode == OP_MINPLUS

5510 { -

5511

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5512

never executed (the execution status of this line is deduced): current->topfallbacks = ((void *)0);

5513

compile_char1_hotpath(common, type, cc, &current->topfallbacks);

never executed: }

5514

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &current->topfallbacks);

5515

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5516

JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((iterator_fallback*)current)->hotpath));

5517

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5518

never executed (the execution status of this line is deduced): free_stack(common, 1);

5519

if (opcode == OP_CRMINRANGE)

never executed: break;

5520 -

5521 case OP_MINUPTO: -

5522 case OP_CRMINRANGE: -

5523

never evaluated: opcode == OP_CRMINRANGE

5524 { -

5525

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5526

never executed (the execution status of this line is deduced): current->topfallbacks = ((void *)0);

5527

never executed (the execution status of this line is deduced): label = sljit_emit_label(compiler);

5528

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: }

5529

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5530

compile_char1_hotpath(common, type, cc, &current->topfallbacks);

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &current->topfallbacks);

5531 -

5532

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

5533

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

5534

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (1), (0), (0x200), (1));

5535

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))), (1), (0));

5536 -

5537

if (opcode == OP_CRMINRANGE)

never evaluated: opcode == OP_CRMINRANGE

5538

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2 + 1, label);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (arg2 + 1)), (label));

5539 -

5540

if (opcode == OP_CRMINRANGE && arg1 == 0)

never evaluated: opcode == OP_CRMINRANGE

never evaluated: arg1 == 0

5541

JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);

never executed: sljit_set_label(sljit_emit_jump(compiler, (22)), (((iterator_fallback*)current)->hotpath));

5542 else -

5543

CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 2, CURRENT_AS(iterator_fallback)->hotpath);

never executed: sljit_set_label(sljit_emit_cmp(compiler, (2), (1), (0), (0x200), (arg1 + 2)), (((iterator_fallback*)current)->hotpath));

5544 -

5545

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5546

never executed (the execution status of this line is deduced): free_stack(common, 2);

5547

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: break;

5548 -

5549 case OP_QUERY: -

5550

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5551

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5552

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((iterator_fallback*)current)->hotpath));

5553

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (22));

5554

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5555

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5556

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5557

JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((iterator_fallback*)current)->hotpath));

5558

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

5559

never executed (the execution status of this line is deduced): free_stack(common, 1);

5560

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: break;

5561 -

5562 case OP_MINQUERY: -

5563

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5564

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5565

jump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): jump = sljit_emit_cmp(compiler, (0), (6), (0), (0x200), (0));

5566

compile_char1_hotpath(common, type, cc, &current->topfallbacks);

never executed (the execution status of this line is deduced): compile_char1_hotpath(common, type, cc, &current->topfallbacks);

5567

JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((iterator_fallback*)current)->hotpath));

5568

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5569

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

5570

never executed (the execution status of this line is deduced): free_stack(common, 1);

5571

never executed: break;

5572 -

5573 case OP_EXACT: -

5574 case OP_POSPLUS: -

5575

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5576

never executed: break;

5577 -

5578 case OP_POSSTAR: -

5579 case OP_POSQUERY: -

5580 case OP_POSUPTO: -

5581

never executed: break;

5582 -

5583 default: -

5584

never executed: }

never evaluated: 0

5585

never executed: break;

5586 } -

5587

executed: }

Execution Count:8

5588 -

5589 static void compile_ref_iterator_fallbackpath(compiler_common *common, struct fallback_common *current) -

5590 { -

5591

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5592

never executed (the execution status of this line is deduced): pcre_uchar *cc = current->cc;

5593

type = cc[1 + IMM2_SIZE];

never executed (the execution status of this line is deduced): pcre_uchar type;

5594 -

5595

never executed (the execution status of this line is deduced): type = cc[1 + 1];

5596

if ((type & 0x1) == 0)

never evaluated: (type & 0x1) == 0

5597 { -

5598

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5599

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5600

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): free_stack(common, 1);

5601

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((iterator_fallback*)current)->hotpath));

5602

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: return;

5603 } -

5604 -

5605

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5606

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((iterator_fallback*)current)->hotpath));

5607

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5608

never executed (the execution status of this line is deduced): free_stack(common, 2);

5609

never executed: }

5610 -

5611 static void compile_recurse_fallbackpath(compiler_common *common, struct fallback_common *current) -

5612 { -

5613

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5614 -

5615

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5616

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5617

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

5618

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), (3), (0));

5619

never executed: }

5620 -

5621 static void compile_assert_fallbackpath(compiler_common *common, struct fallback_common *current) -

5622 { -

5623

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5624

never executed (the execution status of this line is deduced): pcre_uchar *cc = current->cc;

5625

struct sljit_jump *brajump = NULL;

never executed (the execution status of this line is deduced): pcre_uchar bra = OP_BRA;

5626

never executed (the execution status of this line is deduced): struct sljit_jump *brajump = ((void *)0);

5627 -

5628

SLJIT_ASSERT(*cc != OP_BRAMINZERO);

never executed: }

never evaluated: 0

5629

if (*cc == OP_BRAZERO)

never evaluated: *cc == OP_BRAZERO

5630 { -

5631

never executed (the execution status of this line is deduced): bra = *cc;

5632

never executed (the execution status of this line is deduced): cc++;

5633

never executed: }

5634 -

5635

SLJIT_ASSERT(current->topfallbacks == NULL);

never evaluated: bra == OP_BRAZERO

5636 { -

5637

never executed: }

never evaluated: 0

5638

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5639

if (CURRENT_AS(assert_fallback)->framesize < 0)

never executed: }

5640 -

5641

never evaluated: ((assert_fallback*)current)->framesize < 0

5642 { -

5643

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5644 -

5645

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never evaluated: bra == OP_BRAZERO

5646 { -

5647

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5648

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((assert_fallback*)current)->hotpath));

5649

never executed (the execution status of this line is deduced): free_stack(common, 1);

never executed: }

never executed: return;

5652 } -

5653 -

5654

if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)

never evaluated: bra == OP_BRAZERO

5655 { -

5656

never evaluated: *cc == OP_ASSERT_NOT

never evaluated: *cc == OP_ASSERTBACK_NOT

5657 { -

5658

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5659

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((assert_fallback*)current)->hotpath));

5660

never executed (the execution status of this line is deduced): free_stack(common, 1);

5661

never executed: return;

5662 } -

5663

brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

5664

never executed (the execution status of this line is deduced): brajump = sljit_emit_cmp(compiler, (0), (6), (0), (0x200), (0));

5665

if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)

never executed: }

5666 -

5667

never evaluated: *cc == OP_ASSERT

never evaluated: *cc == OP_ASSERTBACK

5668 { -

5669

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (((assert_fallback*)current)->localptr));

5670

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

5671

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_fallback)->framesize * sizeof(sljit_w));

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((assert_fallback*)current)->localptr), ((0x100 | (2))), (((assert_fallback*)current)->framesize * sizeof(sljit_w)));

5672 -

5673

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5674

never executed: }

5675 else -

5676

never executed: set_jumps(current->topfallbacks, sljit_emit_label(compiler));

5677 -

5678

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never evaluated: bra == OP_BRAZERO

5679 { -

5680 /* We know there is enough place on the stack. */ -

5681

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

5682

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5683

JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_fallback)->hotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((assert_fallback*)current)->hotpath));

5684

JUMPHERE(brajump);

never executed (the execution status of this line is deduced): sljit_set_label((brajump), sljit_emit_label(compiler));

never executed: }

never executed: }

5687 -

5688 static void compile_bracket_fallbackpath(compiler_common *common, struct fallback_common *current) -

5689 { -

5690

int localptr = CURRENT_AS(bracket_fallback)->localptr;

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

5691

int opcode;

executed (the execution status of this line is deduced): int opcode;

5692

int offset = 0;

executed (the execution status of this line is deduced): int offset = 0;

5693

executed (the execution status of this line is deduced): int localptr = ((bracket_fallback*)current)->localptr;

5694

int stacksize;

executed (the execution status of this line is deduced): int stacksize;

5695

int count;

executed (the execution status of this line is deduced): int count;

5696

executed (the execution status of this line is deduced): pcre_uchar *cc = current->cc;

5697

jump_list *jumplist = NULL;

executed (the execution status of this line is deduced): pcre_uchar *ccbegin;

5698

pcre_uchar *ccprev;

executed (the execution status of this line is deduced): pcre_uchar *ccprev;

5699

executed (the execution status of this line is deduced): jump_list *jumplist = ((void *)0);

5700

jump_list *jumplistitem = NULL;

executed (the execution status of this line is deduced): jump_list *jumplistitem = ((void *)0);

5701

struct sljit_jump *brazero = NULL;

executed (the execution status of this line is deduced): pcre_uchar bra = OP_BRA;

5702

pcre_uchar ket;

executed (the execution status of this line is deduced): pcre_uchar ket;

5703

assert_fallback *assert;

executed (the execution status of this line is deduced): assert_fallback *assert;

5704

BOOL has_alternatives;

executed (the execution status of this line is deduced): BOOL has_alternatives;

5705

executed (the execution status of this line is deduced): struct sljit_jump *brazero = ((void *)0);

5706

struct sljit_jump *once = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *once = ((void *)0);

5707

struct sljit_jump *cond = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *cond = ((void *)0);

5708

struct sljit_label *rminlabel = NULL;

executed (the execution status of this line is deduced): struct sljit_label *rminlabel = ((void *)0);

5709 -

5710

if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)

partially evaluated: *cc == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: *cc == OP_BRAMINZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5711 { -

5712

never executed (the execution status of this line is deduced): bra = *cc;

5713

never executed (the execution status of this line is deduced): cc++;

5714

never executed: }

5715 -

5716

executed (the execution status of this line is deduced): opcode = *cc;

5717

ket = *(bracketend(ccbegin) - 1 - LINK_SIZE);

executed (the execution status of this line is deduced): ccbegin = cc;

5718

executed (the execution status of this line is deduced): ket = *(bracketend(ccbegin) - 1 - 1);

5719

has_alternatives = *cc == OP_ALT;

executed (the execution status of this line is deduced): cc += (cc[1]);

5720

executed (the execution status of this line is deduced): has_alternatives = *cc == OP_ALT;

5721

if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))

partially evaluated: __builtin_expect((opcode == OP_COND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: __builtin_expect((opcode == OP_SCOND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5722

has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_fallback)->u.condfailed != NULL;

never executed:

has_alternatives = (ccbegin[1 + 1] >= OP_ASSERT && ccbegin[1 + 1] <= OP_ASSERTBACK_NOT) || ((bracket_fallback*)current)->u.condfailed != ((void *)0);

never evaluated: ccbegin[1 + 1] >= OP_ASSERT

never evaluated: ccbegin[1 + 1] <= OP_ASSERTBACK_NOT

never evaluated: ((bracket_fallback*)current)->u.condfailed != ((void *)0)

5723

if (opcode == OP_CBRA || opcode == OP_SCBRA)

partially evaluated: opcode == OP_CBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5724

offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;

never executed: offset = (ccbegin[1 + 1]) << 1;

5725

if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))

partially evaluated: __builtin_expect((opcode == OP_COND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

never evaluated: *cc == OP_KETRMAX

never evaluated: *cc == OP_KETRMIN

0-15

5726

opcode = OP_SCOND;

never executed: opcode = OP_SCOND;

5727

if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))

partially evaluated: __builtin_expect((opcode == OP_ONCE_NC), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5728

opcode = OP_ONCE;

never executed: opcode = OP_ONCE;

5729 -

5730

partially evaluated: ket == OP_KETRMAX

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5731 { -

5732

if (bra != OP_BRAZERO)

never evaluated: bra != OP_BRAZERO

5733

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: free_stack(common, 1);

5734 else -

5735 { -

5736

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5737

brazero = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

5738

never executed (the execution status of this line is deduced): brazero = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (0));

5739

never executed: }

5740 } -

5741

if (bra != OP_BRAMINZERO)

partially evaluated: ket == OP_KETRMIN

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5742 { -

5743

never evaluated: bra != OP_BRAMINZERO

5744 { -

5745

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5746

if (opcode >= OP_SBRA || opcode == OP_ONCE)

never evaluated: opcode >= OP_SBRA

never evaluated: opcode == OP_ONCE

5747 { -

5748 /* Checking zero-length iteration. */ -

5749

if (opcode != OP_ONCE || CURRENT_AS(bracket_fallback)->u.framesize < 0)

never evaluated: opcode != OP_ONCE

never evaluated: ((bracket_fallback*)current)->u.framesize < 0

5750

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, CURRENT_AS(bracket_fallback)->recursivehotpath);

never executed:

sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), ((0x100 | (11))), (localptr)), (((bracket_fallback*)current)->recursivehotpath));

5751 else -

5752 { -

5753

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

5754

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w), CURRENT_AS(bracket_fallback)->recursivehotpath);

never executed (the execution status of this line is deduced):

 sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), ((0x100 | (1))), ((((bracket_fallback*)current)->u.framesize + 1) * sizeof(sljit_w))), (((bracket_fallback*)current)->recursivehotpath));

5755

never executed: }

5756

never evaluated: opcode != OP_ONCE

5757

never executed: free_stack(common, 1);

5758

JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->recursivehotpath);

never executed: }

5759 else -

5760

never executed: sljit_set_label(sljit_emit_jump(compiler, (22)), (((bracket_fallback*)current)->recursivehotpath));

5761 } -

5762

rminlabel = LABEL();

never executed (the execution status of this line is deduced): rminlabel = sljit_emit_label(compiler);

5763

else if (bra == OP_BRAZERO)

never executed: }

5764

partially evaluated: bra == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5765 { -

5766

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5767

brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

5768

never executed (the execution status of this line is deduced): brazero = sljit_emit_cmp(compiler, (1), (1), (0), (0x200), (0));

5769

if (SLJIT_UNLIKELY(opcode == OP_ONCE))

never executed: }

5770 -

5771

partially evaluated: __builtin_expect((opcode == OP_ONCE), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5772 { -

5773

if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)

never evaluated: ((bracket_fallback*)current)->u.framesize >= 0

5774 { -

5775

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

5776

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

5777

never executed: }

5778

once = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): once = sljit_emit_jump(compiler, (22));

5779

else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))

never executed: }

5780

partially evaluated: __builtin_expect((opcode == OP_COND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: __builtin_expect((opcode == OP_SCOND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5781 { -

5782

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never evaluated: has_alternatives

5783 { -

5784 /* Always exactly one alternative. */ -

5785

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5786

jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));

never executed (the execution status of this line is deduced): free_stack(common, 1);

5787 -

5788

never executed (the execution status of this line is deduced): jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));

5789

if (SLJIT_UNLIKELY(!jumplistitem))

never evaluated: __builtin_expect((!jumplistitem), 0)

5790

jumplistitem->next = NULL;

never executed: return;

5791

jumplist = jumplistitem;

never executed (the execution status of this line is deduced): jumplist = jumplistitem;

5792

never executed (the execution status of this line is deduced): jumplistitem->next = ((void *)0);

5793

jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 1);

never executed (the execution status of this line is deduced): jumplistitem->jump = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (1));

never executed: }

never executed: }

else if (*cc == OP_ALT)

evaluated: *cc == OP_ALT

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

5797 { -

5798 /* Build a jump list. Get the last successfully matched branch index. */ -

5799

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5800

executed (the execution status of this line is deduced): free_stack(common, 1);

5801

jumplistitem->next = sljit_alloc_memory(compiler, sizeof(jump_list));

executed (the execution status of this line is deduced): count = 1;

5802 do -

5803 { -

5804 /* Append as the last item. */ -

5805

if (jumplist != NULL)

partially evaluated: jumplist != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5806 { -

5807

never executed (the execution status of this line is deduced): jumplistitem->next = sljit_alloc_memory(compiler, sizeof(jump_list));

5808

jumplistitem = jumplistitem->next;

never executed (the execution status of this line is deduced): jumplistitem = jumplistitem->next;

5809

jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));

never executed: }

5810 else -

5811 { -

5812

executed (the execution status of this line is deduced): jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));

5813

jumplist = jumplistitem;

executed (the execution status of this line is deduced): jumplist = jumplistitem;

5814

if (SLJIT_UNLIKELY(!jumplistitem))

executed: }

Execution Count:1

5815 -

5816

partially evaluated: __builtin_expect((!jumplistitem), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5817

jumplistitem->next = NULL;

never executed: return;

5818 -

5819

executed (the execution status of this line is deduced): jumplistitem->next = ((void *)0);

5820

jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, count++);

executed (the execution status of this line is deduced): jumplistitem->jump = sljit_emit_cmp(compiler, (0), (1), (0), (0x200), (count++));

5821

executed (the execution status of this line is deduced): cc += (cc[1]);

5822

cc = ccbegin + GET(ccbegin, 1);

executed: }

Execution Count:1

5823

while (*cc == OP_ALT);

partially evaluated: *cc == OP_ALT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5824 -

5825

executed (the execution status of this line is deduced): cc = ccbegin + (ccbegin[1]);

5826

COMPILE_FALLBACKPATH(current->top);

executed: }

Execution Count:1

5827 -

5828

never executed: return;

executed: }

Execution Count:15

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5829

if (current->topfallbacks)

evaluated: current->topfallbacks

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:8

7-8

5830

if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))

executed: set_jumps(current->topfallbacks, sljit_emit_label(compiler));

Execution Count:7

5831 -

5832

partially evaluated: __builtin_expect((opcode == OP_COND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: __builtin_expect((opcode == OP_SCOND), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5833 { -

5834 /* Conditional block always has at most one alternative. */ -

5835

if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)

never evaluated: ccbegin[1 + 1] >= OP_ASSERT

never evaluated: ccbegin[1 + 1] <= OP_ASSERTBACK_NOT

5836 { -

5837

assert = CURRENT_AS(bracket_fallback)->u.assert;

never executed: }

never evaluated: 0

5838

never executed (the execution status of this line is deduced): assert = ((bracket_fallback*)current)->u.assert;

5839

if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))

never evaluated: assert->framesize >= 0

never evaluated: ccbegin[1 + 1] == OP_ASSERT

never evaluated: ccbegin[1 + 1] == OP_ASSERTBACK

5840 { -

5841

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (assert->localptr));

5842

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

5843

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_w));

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), ((0x100 | (11))), (assert->localptr), ((0x100 | (2))), (assert->framesize * sizeof(sljit_w)));

5844

set_jumps(CURRENT_AS(bracket_fallback)->u.assert->condfailed, LABEL());

never executed: }

5845

cond = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): cond = sljit_emit_jump(compiler, (22));

5846

never executed (the execution status of this line is deduced): set_jumps(((bracket_fallback*)current)->u.assert->condfailed, sljit_emit_label(compiler));

5847

else if (CURRENT_AS(bracket_fallback)->u.condfailed != NULL)

never executed: }

5848

never evaluated: ((bracket_fallback*)current)->u.condfailed != ((void *)0)

5849 { -

5850

set_jumps(CURRENT_AS(bracket_fallback)->u.condfailed, LABEL());

never executed: }

never evaluated: 0

5851

cond = JUMP(SLJIT_JUMP);

never executed (the execution status of this line is deduced): cond = sljit_emit_jump(compiler, (22));

5852

never executed (the execution status of this line is deduced): set_jumps(((bracket_fallback*)current)->u.condfailed, sljit_emit_label(compiler));

5853

SLJIT_ASSERT(!has_alternatives);

never executed: }

5854 else -

5855

never executed: }

never evaluated: 0

5856 } -

5857 -

5858

evaluated: has_alternatives

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

5859 { -

5860

executed (the execution status of this line is deduced): count = 1;

5861 do -

5862 { -

5863

current->top = NULL;

executed (the execution status of this line is deduced): current->top = ((void *)0);

5864

current->nextfallbacks = NULL;

executed (the execution status of this line is deduced): current->topfallbacks = ((void *)0);

5865

executed (the execution status of this line is deduced): current->nextfallbacks = ((void *)0);

5866

if (*cc == OP_ALT)

partially evaluated: *cc == OP_ALT

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5867 { -

5868

ccprev = cc + 1 + LINK_SIZE;

executed (the execution status of this line is deduced): ccprev = cc + 1 + 1;

5869

if (opcode != OP_COND && opcode != OP_SCOND)

executed (the execution status of this line is deduced): cc += (cc[1]);

5870

partially evaluated: opcode != OP_COND

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: opcode != OP_SCOND

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5871 { -

5872

if (localptr != 0 && opcode != OP_ONCE)

partially evaluated: localptr != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

never evaluated: opcode != OP_ONCE

0-1

5873

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), (localptr));

5874 else -

5875

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

Execution Count:1

5876 } -

5877

compile_hotpath(common, ccprev, cc, current);

executed (the execution status of this line is deduced): compile_hotpath(common, ccprev, cc, current);

5878

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5879

never executed: return;

5880

executed: }

Execution Count:1

5881 -

5882 /* Instructions after the current alternative is succesfully matched. */ -

5883 /* There is a similar code in compile_bracket_hotpath. */ -

5884

if (CURRENT_AS(bracket_fallback)->u.framesize < 0)

partially evaluated: opcode == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5885 { -

5886

never evaluated: ((bracket_fallback*)current)->u.framesize < 0

5887 { -

5888

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (localptr));

5889 /* TMP2 which is set here used by OP_KETRMAX below. */ -

5890

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);

never evaluated: ket == OP_KETRMAX

5891

never executed: sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (0));

5892

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);

never evaluated: ket == OP_KETRMIN

5893 { -

5894 /* Move the STR_PTR to the localptr. */ -

5895

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (0));

5896

OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (CURRENT_AS(bracket_fallback)->u.framesize + 2) * sizeof(sljit_w));

never executed: }

5897 } -

5898 else -

5899 { -

5900

never executed (the execution status of this line is deduced):

 sljit_emit_op2(compiler, (23), (2), (0), ((0x100 | (11))), (localptr), (0x200), ((((bracket_fallback*)current)->u.framesize + 2) * sizeof(sljit_w)));

5901

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never evaluated: ket == OP_KETRMAX

5902 { -

5903 /* TMP2 which is set here used by OP_KETRMAX below. */ -

5904

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

never executed: }

never executed: }

5907 } -

5908 -

5909

executed (the execution status of this line is deduced): stacksize = 0;

5910

partially evaluated: opcode != OP_ONCE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5911

if (ket != OP_KET || bra != OP_BRA)

executed: stacksize++;

Execution Count:1

5912

partially evaluated: ket != OP_KET

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

partially evaluated: bra != OP_BRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5913

if (opcode != OP_ONCE || CURRENT_AS(bracket_fallback)->u.framesize >= 0)

never executed: stacksize++;

5914 -

5915

if (stacksize > 0) {

partially evaluated: stacksize > 0

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5916

partially evaluated: opcode != OP_ONCE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

never evaluated: ((bracket_fallback*)current)->u.framesize >= 0

0-1

5917

SLJIT_ASSERT(stacksize == 1);

executed: allocate_stack(common, stacksize);

Execution Count:1

5918 else -

5919 { -

5920 /* We know we have place at least for one item on the top of the stack. */ -

5921

never executed: }

never evaluated: 0

5922

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), (sizeof(sljit_w)));

5923

never executed: }

5924 } -

5925 -

5926

if (ket != OP_KET || bra != OP_BRA)

executed (the execution status of this line is deduced): stacksize = 0;

5927

partially evaluated: ket != OP_KET

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

partially evaluated: bra != OP_BRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5928 { -

5929

if (ket != OP_KET)

never evaluated: ket != OP_KET

5930

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (6), (0));

5931 else -

5932

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (0x200), (0));

5933

never executed (the execution status of this line is deduced): stacksize++;

5934

never executed: }

5935 -

5936

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);

partially evaluated: opcode != OP_ONCE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5937

executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(stacksize) - 1) * (int)sizeof(sljit_w))), (0x200), (count++));

Execution Count:1

5938 -

5939

if (offset != 0)

partially evaluated: offset != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5940 { -

5941

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (11))), (localptr));

5942

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (6), (0));

5943

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 0) * sizeof(sljit_w))), (1), (0));

5944

JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->althotpath);

never executed: }

5945 -

5946

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((bracket_fallback*)current)->althotpath));

5947 -

5948

JUMPHERE(jumplist->jump);

partially evaluated: opcode != OP_ONCE

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5949 { -

5950

SLJIT_ASSERT(jumplist);

executed: }

Execution Count:1

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5951

executed (the execution status of this line is deduced): sljit_set_label((jumplist->jump), sljit_emit_label(compiler));

5952

jumplist = jumplist->next;

executed (the execution status of this line is deduced): jumplist = jumplist->next;

5953

COMPILE_FALLBACKPATH(current->top);

executed: }

Execution Count:1

5954 -

5955

never executed: return;

executed: }

Execution Count:1

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5956

if (current->topfallbacks)

partially evaluated: current->topfallbacks

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5957

SLJIT_ASSERT(!current->nextfallbacks);

executed: set_jumps(current->topfallbacks, sljit_emit_label(compiler));

Execution Count:1

5958

executed: }

Execution Count:1

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5959

SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);

executed: }

Execution Count:1

5960

while (*cc == OP_ALT);

partially evaluated: *cc == OP_ALT

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5961

SLJIT_ASSERT(!jumplist);

executed: }

Execution Count:1

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5962 -

5963

if (cond != NULL)

partially evaluated: cond != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

5964 { -

5965

never executed: }

never evaluated: 0

5966

assert = CURRENT_AS(bracket_fallback)->u.assert;

never executed (the execution status of this line is deduced): assert = ((bracket_fallback*)current)->u.assert;

5967

if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)

never evaluated: ccbegin[1 + 1] == OP_ASSERT_NOT

never evaluated: ccbegin[1 + 1] == OP_ASSERTBACK_NOT

never evaluated: assert->framesize >= 0

5968 -

5969 { -

5970

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (assert->localptr));

5971

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

5972

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_w));

never executed (the execution status of this line is deduced):

 sljit_emit_op1(compiler, (6), ((0x100 | (11))), (assert->localptr), ((0x100 | (2))), (assert->framesize * sizeof(sljit_w)));

never executed: }

never executed (the execution status of this line is deduced): sljit_set_label((cond), sljit_emit_label(compiler));

5975

never executed: }

5976 -

5977 /* Free the STR_PTR. */ -

5978

if (localptr == 0)

partially evaluated: localptr == 0

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-1

5979

executed: free_stack(common, 1);

Execution Count:1

5980

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

executed: }

Execution Count:1

5981 -

5982

if (offset != 0)

partially evaluated: offset != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5983 { -

5984 /* Using both tmp register is better for instruction scheduling. */ -

5985

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5986

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

5987

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))), (1), (0));

5988

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (3), (0));

5989

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), STACK(2));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (((-(2) - 1) * (int)sizeof(sljit_w))));

5990

free_stack(common, 3);

never executed (the execution status of this line is deduced): free_stack(common, 3);

5991

else if (opcode == OP_SBRA || opcode == OP_SCOND)

never executed: }

5992

partially evaluated: opcode == OP_SBRA

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

partially evaluated: opcode == OP_SCOND

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5993 { -

5994

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

5995

never executed (the execution status of this line is deduced): free_stack(common, 1);

5996

else if (opcode == OP_ONCE)

never executed: }

5997

partially evaluated: opcode == OP_ONCE

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

5998 { -

5999

cc = ccbegin + GET(ccbegin, 1);

never executed (the execution status of this line is deduced): cc = ccbegin + (ccbegin[1]);

6000

if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)

never evaluated: ((bracket_fallback*)current)->u.framesize >= 0

6001 { -

6002 /* Reset head and drop saved frame. */ -

6003

stacksize = (ket == OP_KETRMAX || ket == OP_KETRMIN || *cc == OP_ALT) ? 2 : 1;

never evaluated: ket == OP_KETRMAX

never evaluated: ket == OP_KETRMIN

never evaluated: *cc == OP_ALT

6004

free_stack(common, CURRENT_AS(bracket_fallback)->u.framesize + stacksize);

never executed (the execution status of this line is deduced): free_stack(common, ((bracket_fallback*)current)->u.framesize + stacksize);

6005

else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))

never executed: }

6006

never evaluated: ket == OP_KETRMAX

never evaluated: *cc == OP_ALT

never evaluated: ket != OP_KETRMIN

6007 { -

6008 /* The STR_PTR must be released. */ -

6009

never executed (the execution status of this line is deduced): free_stack(common, 1);

6010

if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)

never executed: }

6011 -

6012

JUMPHERE(once);

never executed (the execution status of this line is deduced): sljit_set_label((once), sljit_emit_label(compiler));

6013 /* Restore previous localptr */ -

6014

never evaluated: ((bracket_fallback*)current)->u.framesize >= 0

6015

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_fallback)->u.framesize * sizeof(sljit_w));

never executed:

sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), ((0x100 | (2))), (((bracket_fallback*)current)->u.framesize * sizeof(sljit_w)));

6016

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never evaluated: ket == OP_KETRMIN

6017 { -

6018

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

6019 /* See the comment below. */ -

6020

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);

never executed (the execution status of this line is deduced): free_stack(common, 2);

6021

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (localptr), (1), (0));

6022

never executed: }

6023 } -

6024 -

6025

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

partially evaluated: ket == OP_KETRMAX

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6026 { -

6027

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

6028

CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_fallback)->recursivehotpath);

never executed (the execution status of this line is deduced):

 sljit_set_label(sljit_emit_cmp(compiler, (1), (6), (0), (0x200), (0)), (((bracket_fallback*)current)->recursivehotpath));

6029

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never evaluated: bra == OP_BRAZERO

6030 { -

6031

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

6032

JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->zerohotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((bracket_fallback*)current)->zerohotpath));

6033

JUMPHERE(brazero);

never executed (the execution status of this line is deduced): sljit_set_label((brazero), sljit_emit_label(compiler));

6034

never executed: }

6035

never executed (the execution status of this line is deduced): free_stack(common, 1);

6036

never executed: }

6037

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

partially evaluated: ket == OP_KETRMIN

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6038 { -

6039

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

6040 -

6041 /* OP_ONCE removes everything in case of a fallback, so we don't -

6042 need to explicitly release the STR_PTR. The extra release would -

6043 affect badly the free_stack(2) above. */ -

6044

never evaluated: opcode != OP_ONCE

6045

CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rminlabel);

never executed: free_stack(common, 1);

6046

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (1), (0), (0x200), (0)), (rminlabel));

6047

free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);

never evaluated: opcode == OP_ONCE

6048

never executed: free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);

6049

never evaluated: bra == OP_BRAMINZERO

6050

else if (bra == OP_BRAZERO)

never executed: free_stack(common, 1);

6051 } -

6052

partially evaluated: bra == OP_BRAZERO

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6053 { -

6054

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

6055

JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->zerohotpath);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (((bracket_fallback*)current)->zerohotpath));

6056

JUMPHERE(brazero);

never executed (the execution status of this line is deduced): sljit_set_label((brazero), sljit_emit_label(compiler));

6057

never executed: }

6058 } -

6059 -

6060 static void compile_bracketpos_fallbackpath(compiler_common *common, struct fallback_common *current) -

6061 { -

6062

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

6063

int offset;

never executed (the execution status of this line is deduced): int offset;

6064

if (CURRENT_AS(bracketpos_fallback)->framesize < 0)

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

6065 -

6066

never evaluated: ((bracketpos_fallback*)current)->framesize < 0

6067 { -

6068

if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)

never evaluated: *current->cc == OP_CBRAPOS

never evaluated: *current->cc == OP_SCBRAPOS

6069 { -

6070

offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;

never executed (the execution status of this line is deduced): offset = (current->cc[1 + 1]) << 1;

6071

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

6072

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (((-(1) - 1) * (int)sizeof(sljit_w))));

6073

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset) * sizeof(sljit_w))), (1), (0));

6074

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (offset + 1) * sizeof(sljit_w))), (3), (0));

6075

never executed: }

6076

free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

6077

never executed (the execution status of this line is deduced): free_stack(common, ((bracketpos_fallback*)current)->stacksize);

6078

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_fallback)->localptr);

never executed: return;

6079 } -

6080 -

6081

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), (((bracketpos_fallback*)current)->localptr));

6082

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

6083 -

6084

if (current->topfallbacks)

never evaluated: current->topfallbacks

6085 { -

6086

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (22));

6087

free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

6088 /* Drop the stack frame. */ -

6089

never executed (the execution status of this line is deduced): free_stack(common, ((bracketpos_fallback*)current)->stacksize);

6090

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

6091

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_fallback)->framesize * sizeof(sljit_w));

never executed: }

6092

never executed (the execution status of this line is deduced):

sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((bracketpos_fallback*)current)->localptr), ((0x100 | (2))), (((bracketpos_fallback*)current)->framesize * sizeof(sljit_w)));

6093

assert_fallback fallback;

never executed: }

6094 -

6095 static void compile_braminzero_fallbackpath(compiler_common *common, struct fallback_common *current) -

6096 { -

6097

never executed (the execution status of this line is deduced): assert_fallback fallback;

6098 -

6099

current->top = NULL;

never executed (the execution status of this line is deduced): current->top = ((void *)0);

6100

current->nextfallbacks = NULL;

never executed (the execution status of this line is deduced): current->topfallbacks = ((void *)0);

6101

never executed (the execution status of this line is deduced): current->nextfallbacks = ((void *)0);

6102

if (current->cc[1] > OP_ASSERTBACK_NOT)

never evaluated: current->cc[1] > OP_ASSERTBACK_NOT

6103 { -

6104 /* Manual call of compile_bracket_hotpath and compile_bracket_fallbackpath. */ -

6105

compile_bracket_hotpath(common, current->cc, current);

never executed (the execution status of this line is deduced): compile_bracket_hotpath(common, current->cc, current);

6106

compile_bracket_fallbackpath(common, current->top);

never executed (the execution status of this line is deduced): compile_bracket_fallbackpath(common, current->top);

6107

memset(&fallback, 0, sizeof(fallback));

never executed: }

6108 else -

6109 { -

6110

never executed (the execution status of this line is deduced): memset(&fallback, 0, sizeof(fallback));

6111

fallback.common.cc = current->cc;

never executed (the execution status of this line is deduced): fallback.common.cc = current->cc;

6112

fallback.hotpath = CURRENT_AS(braminzero_fallback)->hotpath;

never executed (the execution status of this line is deduced): fallback.hotpath = ((braminzero_fallback*)current)->hotpath;

6113 /* Manual call of compile_assert_hotpath. */ -

6114

compile_assert_hotpath(common, current->cc, &fallback, FALSE);

never executed (the execution status of this line is deduced): compile_assert_hotpath(common, current->cc, &fallback, 0);

6115

SLJIT_ASSERT(!current->nextfallbacks && !current->topfallbacks);

never executed: }

6116

never executed: }

never evaluated: 0

6117

never executed: }

6118 -

6119 static void compile_fallbackpath(compiler_common *common, struct fallback_common *current) -

6120 { -

6121

if (current->nextfallbacks != NULL)

executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

6122 -

6123

while (current)

evaluated: current

TRUE	FALSE
yes Evaluation Count:23	yes Evaluation Count:31

23-31

6124 { -

6125

partially evaluated: current->nextfallbacks != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:23

0-23

6126

set_jumps(current->nextfallbacks, LABEL());

never executed: set_jumps(current->nextfallbacks, sljit_emit_label(compiler));

6127 switch(*current->cc) -

6128 { -

6129 case OP_SET_SOM: -

6130

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

6131

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP1, 0);

never executed (the execution status of this line is deduced): free_stack(common, 1);

6132

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), (1), (0));

6133

compile_iterator_fallbackpath(common, current);

never executed: break;

6134 -

6135 case OP_STAR: -

6136 case OP_MINSTAR: -

6137 case OP_PLUS: -

6138 case OP_MINPLUS: -

6139 case OP_QUERY: -

6140 case OP_MINQUERY: -

6141 case OP_UPTO: -

6142 case OP_MINUPTO: -

6143 case OP_EXACT: -

6144 case OP_POSSTAR: -

6145 case OP_POSPLUS: -

6146 case OP_POSQUERY: -

6147 case OP_POSUPTO: -

6148 case OP_STARI: -

6149 case OP_MINSTARI: -

6150 case OP_PLUSI: -

6151 case OP_MINPLUSI: -

6152 case OP_QUERYI: -

6153 case OP_MINQUERYI: -

6154 case OP_UPTOI: -

6155 case OP_MINUPTOI: -

6156 case OP_EXACTI: -

6157 case OP_POSSTARI: -

6158 case OP_POSPLUSI: -

6159 case OP_POSQUERYI: -

6160 case OP_POSUPTOI: -

6161 case OP_NOTSTAR: -

6162 case OP_NOTMINSTAR: -

6163 case OP_NOTPLUS: -

6164 case OP_NOTMINPLUS: -

6165 case OP_NOTQUERY: -

6166 case OP_NOTMINQUERY: -

6167 case OP_NOTUPTO: -

6168 case OP_NOTMINUPTO: -

6169 case OP_NOTEXACT: -

6170 case OP_NOTPOSSTAR: -

6171 case OP_NOTPOSPLUS: -

6172 case OP_NOTPOSQUERY: -

6173 case OP_NOTPOSUPTO: -

6174 case OP_NOTSTARI: -

6175 case OP_NOTMINSTARI: -

6176 case OP_NOTPLUSI: -

6177 case OP_NOTMINPLUSI: -

6178 case OP_NOTQUERYI: -

6179 case OP_NOTMINQUERYI: -

6180 case OP_NOTUPTOI: -

6181 case OP_NOTMINUPTOI: -

6182 case OP_NOTEXACTI: -

6183 case OP_NOTPOSSTARI: -

6184 case OP_NOTPOSPLUSI: -

6185 case OP_NOTPOSQUERYI: -

6186 case OP_NOTPOSUPTOI: -

6187 case OP_TYPESTAR: -

6188 case OP_TYPEMINSTAR: -

6189 case OP_TYPEPLUS: -

6190 case OP_TYPEMINPLUS: -

6191 case OP_TYPEQUERY: -

6192 case OP_TYPEMINQUERY: -

6193 case OP_TYPEUPTO: -

6194 case OP_TYPEMINUPTO: -

6195 case OP_TYPEEXACT: -

6196 case OP_TYPEPOSSTAR: -

6197 case OP_TYPEPOSPLUS: -

6198 case OP_TYPEPOSQUERY: -

6199 case OP_TYPEPOSUPTO: -

6200 case OP_CLASS: -

6201 case OP_NCLASS: -

6202 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8 -

6203 case OP_XCLASS: -

6204 #endif -

6205

executed (the execution status of this line is deduced): compile_iterator_fallbackpath(common, current);

6206

compile_ref_iterator_fallbackpath(common, current);

executed: break;

Execution Count:8

6207 -

6208 case OP_REF: -

6209 case OP_REFI: -

6210

never executed (the execution status of this line is deduced): compile_ref_iterator_fallbackpath(common, current);

6211

compile_recurse_fallbackpath(common, current);

never executed: break;

6212 -

6213 case OP_RECURSE: -

6214

never executed (the execution status of this line is deduced): compile_recurse_fallbackpath(common, current);

6215

compile_assert_fallbackpath(common, current);

never executed: break;

6216 -

6217 case OP_ASSERT: -

6218 case OP_ASSERT_NOT: -

6219 case OP_ASSERTBACK: -

6220 case OP_ASSERTBACK_NOT: -

6221

never executed (the execution status of this line is deduced): compile_assert_fallbackpath(common, current);

6222

compile_bracket_fallbackpath(common, current);

never executed: break;

6223 -

6224 case OP_ONCE: -

6225 case OP_ONCE_NC: -

6226 case OP_BRA: -

6227 case OP_CBRA: -

6228 case OP_COND: -

6229 case OP_SBRA: -

6230 case OP_SCBRA: -

6231 case OP_SCOND: -

6232

executed (the execution status of this line is deduced): compile_bracket_fallbackpath(common, current);

6233

if (current->cc[1] > OP_ASSERTBACK_NOT)

executed: break;

Execution Count:15

6234 -

6235 case OP_BRAZERO: -

6236

never evaluated: current->cc[1] > OP_ASSERTBACK_NOT

6237

compile_bracket_fallbackpath(common, current);

never executed: compile_bracket_fallbackpath(common, current);

6238 else -

6239

compile_assert_fallbackpath(common, current);

never executed: compile_assert_fallbackpath(common, current);

6240

compile_bracketpos_fallbackpath(common, current);

never executed: break;

6241 -

6242 case OP_BRAPOS: -

6243 case OP_CBRAPOS: -

6244 case OP_SBRAPOS: -

6245 case OP_SCBRAPOS: -

6246 case OP_BRAPOSZERO: -

6247

never executed (the execution status of this line is deduced): compile_bracketpos_fallbackpath(common, current);

6248

compile_braminzero_fallbackpath(common, current);

never executed: break;

6249 -

6250 case OP_BRAMINZERO: -

6251

never executed (the execution status of this line is deduced): compile_braminzero_fallbackpath(common, current);

6252

never executed: break;

6253 -

6254 case OP_FAIL: -

6255 case OP_ACCEPT: -

6256 case OP_ASSERT_ACCEPT: -

6257

never executed (the execution status of this line is deduced): set_jumps(current->topfallbacks, sljit_emit_label(compiler));

6258

never executed: break;

6259 -

6260 default: -

6261

never executed: }

never evaluated: 0

6262

never executed: break;

6263 } -

6264

current = current->prev;

executed (the execution status of this line is deduced): current = current->prev;

6265

executed: }

Execution Count:23

6266

executed: }

Execution Count:31

6267 -

6268 static SLJIT_INLINE void compile_recurse(compiler_common *common) -

6269 { -

6270

pcre_uchar *cc = common->start + common->currententry->start;

never executed (the execution status of this line is deduced): struct sljit_compiler *compiler = common->compiler;

6271

never executed (the execution status of this line is deduced): pcre_uchar *cc = common->start + common->currententry->start;

6272

pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);

never evaluated: *cc == OP_BRA

6273

pcre_uchar *ccend = bracketend(cc);

never executed (the execution status of this line is deduced): pcre_uchar *ccend = bracketend(cc);

6274

int localsize = get_localsize(common, ccbegin, ccend);

never executed (the execution status of this line is deduced): int localsize = get_localsize(common, ccbegin, ccend);

6275

int framesize = get_framesize(common, cc, TRUE);

never executed (the execution status of this line is deduced): int framesize = get_framesize(common, cc, 1);

6276

int alternativesize;

never executed (the execution status of this line is deduced): int alternativesize;

6277

BOOL needsframe;

never executed (the execution status of this line is deduced): BOOL needsframe;

6278

fallback_common altfallback;

never executed (the execution status of this line is deduced): fallback_common altfallback;

6279

SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);

never executed (the execution status of this line is deduced): struct sljit_jump *jump;

6280 -

6281

never executed: }

never evaluated: 0

6282

needsframe = framesize >= 0;

never executed (the execution status of this line is deduced): needsframe = framesize >= 0;

6283

if (!needsframe)

never evaluated: !needsframe

6284

framesize = 0;

never executed: framesize = 0;

6285

alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;

never evaluated: *(cc + (cc[1])) == OP_ALT

6286 -

6287

SLJIT_ASSERT(common->currententry->entry == NULL);

never executed: }

never evaluated: 0

6288

common->currententry->entry = LABEL();

never executed (the execution status of this line is deduced): common->currententry->entry = sljit_emit_label(compiler);

6289

set_jumps(common->currententry->calls, common->currententry->entry);

never executed (the execution status of this line is deduced): set_jumps(common->currententry->calls, common->currententry->entry);

6290 -

6291

sljit_emit_fast_enter(compiler, TMP2, 0, 1, 5, 5, common->localsize);

never executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, 3, 0, 1, 5, 5, common->localsize);

6292

allocate_stack(common, localsize + framesize + alternativesize);

never executed (the execution status of this line is deduced): allocate_stack(common, localsize + framesize + alternativesize);

6293

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(localsize + framesize + alternativesize - 1), TMP2, 0);

never executed (the execution status of this line is deduced):

sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(localsize + framesize + alternativesize - 1) - 1) * (int)sizeof(sljit_w))), (3), (0));

6294

copy_locals(common, ccbegin, ccend, TRUE, localsize + framesize + alternativesize, framesize + alternativesize);

never executed (the execution status of this line is deduced): copy_locals(common, ccbegin, ccend, 1, localsize + framesize + alternativesize, framesize + alternativesize);

6295

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD, STACK_TOP, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((4 * sizeof(sljit_w))), (2), (0));

6296

if (needsframe)

never evaluated: needsframe

6297

init_frame(common, cc, framesize + alternativesize - 1, alternativesize, FALSE);

never executed: init_frame(common, cc, framesize + alternativesize - 1, alternativesize, 0);

6298 -

6299

if (alternativesize > 0)

never evaluated: alternativesize > 0

6300

OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))), (6), (0));

6301 -

6302

memset(&altfallback, 0, sizeof(fallback_common));

never executed (the execution status of this line is deduced): memset(&altfallback, 0, sizeof(fallback_common));

6303

common->acceptlabel = NULL;

never executed (the execution status of this line is deduced): common->acceptlabel = ((void *)0);

6304

common->accept = NULL;

never executed (the execution status of this line is deduced): common->accept = ((void *)0);

6305

altfallback.cc = ccbegin;

never executed (the execution status of this line is deduced): altfallback.cc = ccbegin;

6306

altfallback.topfallbacks = NULL;

never executed (the execution status of this line is deduced): cc += (cc[1]);

6307

while (1)

never evaluated: 1

6308 { -

6309

altfallback.top = NULL;

never executed (the execution status of this line is deduced): altfallback.top = ((void *)0);

6310

never executed (the execution status of this line is deduced): altfallback.topfallbacks = ((void *)0);

6311 -

6312

if (altfallback.cc != ccbegin)

never evaluated: altfallback.cc != ccbegin

6313

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));

never executed: sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (2))), (((-(0) - 1) * (int)sizeof(sljit_w))));

6314 -

6315

compile_hotpath(common, altfallback.cc, cc, &altfallback);

never executed (the execution status of this line is deduced): compile_hotpath(common, altfallback.cc, cc, &altfallback);

6316

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

6317

add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));

never executed: return;

6318 -

6319

never executed (the execution status of this line is deduced): add_jump(compiler, &common->accept, sljit_emit_jump(compiler, (22)));

6320 -

6321

compile_fallbackpath(common, altfallback.top);

never executed (the execution status of this line is deduced): compile_fallbackpath(common, altfallback.top);

6322

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

6323

set_jumps(altfallback.topfallbacks, LABEL());

never executed: return;

6324

never executed (the execution status of this line is deduced): set_jumps(altfallback.topfallbacks, sljit_emit_label(compiler));

6325 -

6326

if (*cc != OP_ALT)

never evaluated: *cc != OP_ALT

6327

altfallback.cc = cc + 1 + LINK_SIZE;

never executed: break;

6328 -

6329

never executed (the execution status of this line is deduced): altfallback.cc = cc + 1 + 1;

6330

never executed (the execution status of this line is deduced): cc += (cc[1]);

6331

OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);

never executed: }

6332 /* None of them matched. */ -

6333

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), (0x200), (0));

6334

set_jumps(common->accept, LABEL());

never executed (the execution status of this line is deduced): jump = sljit_emit_jump(compiler, (22));

6335 -

6336

never executed (the execution status of this line is deduced): set_jumps(common->accept, sljit_emit_label(compiler));

6337

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (11))), ((4 * sizeof(sljit_w))));

6338

if (needsframe)

never evaluated: needsframe

6339 { -

6340

OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))));

6341

OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25), (2), (0), (2), (0), (0x200), ((framesize + alternativesize) * sizeof(sljit_w)));

6342

add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));

never executed (the execution status of this line is deduced): add_jump(compiler, &common->revertframes, sljit_emit_jump(compiler, (23)));

6343

OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (2), (0), (2), (0), (0x200), ((framesize + alternativesize) * sizeof(sljit_w)));

6344

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP3, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), (5), (0));

6345

OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);

never executed: }

6346

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (5), (0), (0x200), (1));

6347 -

6348

copy_locals(common, ccbegin, ccend, FALSE, localsize + framesize + alternativesize, framesize + alternativesize);

never executed (the execution status of this line is deduced): sljit_set_label((jump), sljit_emit_label(compiler));

6349

never executed (the execution status of this line is deduced): copy_locals(common, ccbegin, ccend, 0, localsize + framesize + alternativesize, framesize + alternativesize);

6350

free_stack(common, localsize + framesize + alternativesize);

never executed (the execution status of this line is deduced): free_stack(common, localsize + framesize + alternativesize);

6351

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_w));

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (2))), (sizeof(sljit_w)));

6352

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD, TMP2, 0);

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (5), (0));

6353

never executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((4 * sizeof(sljit_w))), (3), (0));

6354

sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), 0);

never executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, (0x100 | (2)), 0);

6355

struct sljit_compiler *compiler;

never executed: }

6356 -

6357 #undef COMPILE_FALLBACKPATH -

6358 #undef CURRENT_AS -

6359 -

6360 void -

6361 PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra) -

6362 { -

6363

executed (the execution status of this line is deduced): struct sljit_compiler *compiler;

6364

fallback_common rootfallback;

executed (the execution status of this line is deduced): fallback_common rootfallback;

6365

compiler_common common_data;

executed (the execution status of this line is deduced): compiler_common common_data;

6366

compiler_common *common = &common_data;

executed (the execution status of this line is deduced): compiler_common *common = &common_data;

6367

const pcre_uint8 *tables = re->tables;

executed (the execution status of this line is deduced): const pcre_uint8 *tables = re->tables;

6368

pcre_study_data *study;

executed (the execution status of this line is deduced): pcre_study_data *study;

6369

pcre_uchar *ccend;

executed (the execution status of this line is deduced): pcre_uchar *ccend;

6370

executable_function *function;

executed (the execution status of this line is deduced): executable_function *function;

6371

void *executable_func;

executed (the execution status of this line is deduced): void *executable_func;

6372

sljit_uw executable_size;

executed (the execution status of this line is deduced): sljit_uw executable_size;

6373

struct sljit_label *leave;

executed (the execution status of this line is deduced): struct sljit_label *leave;

6374

struct sljit_label *mainloop = NULL;

executed (the execution status of this line is deduced): struct sljit_label *mainloop = ((void *)0);

6375

struct sljit_label *empty_match_found;

executed (the execution status of this line is deduced): struct sljit_label *empty_match_found;

6376

struct sljit_label *empty_match_fallback;

executed (the execution status of this line is deduced): struct sljit_label *empty_match_fallback;

6377

struct sljit_jump *alloc_error;

executed (the execution status of this line is deduced): struct sljit_jump *alloc_error;

6378

struct sljit_jump *reqbyte_notfound = NULL;

executed (the execution status of this line is deduced): struct sljit_jump *reqbyte_notfound = ((void *)0);

6379

struct sljit_jump *empty_match;

executed (the execution status of this line is deduced): struct sljit_jump *empty_match;

6380 -

6381

SLJIT_ASSERT((extra->flags & PCRE_EXTRA_STUDY_DATA) != 0);

executed: }

Execution Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6382

study = extra->study_data;

executed (the execution status of this line is deduced): study = extra->study_data;

6383 -

6384

if (!tables)

partially evaluated: !tables

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6385

tables = PRIV(default_tables);

executed: tables = _pcre16_default_tables;

Execution Count:15

6386 -

6387

memset(&rootfallback, 0, sizeof(fallback_common));

executed (the execution status of this line is deduced): memset(&rootfallback, 0, sizeof(fallback_common));

6388

rootfallback.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;

executed (the execution status of this line is deduced): rootfallback.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;

6389 -

6390

common->compiler = NULL;

executed (the execution status of this line is deduced): common->compiler = ((void *)0);

6391

common->start = rootfallback.cc;

executed (the execution status of this line is deduced): common->start = rootfallback.cc;

6392

common->cbraptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_w);

executed (the execution status of this line is deduced): common->cbraptr = (8 * sizeof(sljit_w)) + (re->top_bracket + 1) * 2 * sizeof(sljit_w);

6393

common->fcc = tables + fcc_offset;

executed (the execution status of this line is deduced): common->fcc = tables + 256;

6394

common->lcc = (sljit_w)(tables + lcc_offset);

executed (the execution status of this line is deduced): common->lcc = (sljit_w)(tables + 0);

6395

common->nltype = NLTYPE_FIXED;

executed (the execution status of this line is deduced): common->nltype = 0;

6396 switch(re->options & PCRE_NEWLINE_BITS) -

6397 { -

6398 case 0: -

6399 /* Compile-time default */ -

6400 switch (NEWLINE) -

6401 { -

6402

case -1: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;

never executed: break;

6403

case -2: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;

never executed: break;

6404

default: common->newline = NEWLINE; break;

executed: break;

Execution Count:12

6405 } -

6406

case PCRE_NEWLINE_CR: common->newline = CHAR_CR; break;

executed: break;

Execution Count:12

6407

never executed: break;

6408

case PCRE_NEWLINE_LF: common->newline = CHAR_NL; break;

never executed: break;

6409 case PCRE_NEWLINE_CR+ -

6410

PCRE_NEWLINE_LF: common->newline = (CHAR_CR << 8) | CHAR_NL; break;

executed: break;

Execution Count:2

6411

case PCRE_NEWLINE_ANY: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;

never executed: break;

6412

case PCRE_NEWLINE_ANYCRLF: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;

executed: break;

Execution Count:1

6413

default: return;

never executed: return;

6414 } -

6415

if ((re->options & PCRE_BSR_ANYCRLF) != 0)

partially evaluated: (re->options & 0x00800000) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6416

common->bsr_nltype = NLTYPE_ANYCRLF;

never executed: common->bsr_nltype = 2;

6417

else if ((re->options & PCRE_BSR_UNICODE) != 0)

partially evaluated: (re->options & 0x01000000) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6418

common->bsr_nltype = NLTYPE_ANY;

never executed: common->bsr_nltype = 1;

6419 else -

6420 { -

6421 #ifdef BSR_ANYCRLF -

6422 common->bsr_nltype = NLTYPE_ANYCRLF; -

6423 #else -

6424

common->bsr_nltype = NLTYPE_ANY;

executed (the execution status of this line is deduced): common->bsr_nltype = 1;

6425 #endif -

6426

common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;

executed: }

Execution Count:15

6427

executed (the execution status of this line is deduced): common->endonly = (re->options & 0x00000020) != 0;

6428

common->ctypes = (sljit_w)(tables + ctypes_offset);

executed (the execution status of this line is deduced): common->ctypes = (sljit_w)(tables + (512 + 320));

6429

common->name_table = (sljit_w)((pcre_uchar *)re + re->name_table_offset);

executed (the execution status of this line is deduced): common->name_table = (sljit_w)((pcre_uchar *)re + re->name_table_offset);

6430

common->name_count = re->name_count;

executed (the execution status of this line is deduced): common->name_count = re->name_count;

6431

common->name_entry_size = re->name_entry_size;

executed (the execution status of this line is deduced): common->name_entry_size = re->name_entry_size;

6432

common->acceptlabel = NULL;

executed (the execution status of this line is deduced): common->acceptlabel = ((void *)0);

6433

common->stubs = NULL;

executed (the execution status of this line is deduced): common->stubs = ((void *)0);

6434

common->entries = NULL;

executed (the execution status of this line is deduced): common->entries = ((void *)0);

6435

common->currententry = NULL;

executed (the execution status of this line is deduced): common->currententry = ((void *)0);

6436

common->accept = NULL;

executed (the execution status of this line is deduced): common->accept = ((void *)0);

6437

common->calllimit = NULL;

executed (the execution status of this line is deduced): common->calllimit = ((void *)0);

6438

common->stackalloc = NULL;

executed (the execution status of this line is deduced): common->stackalloc = ((void *)0);

6439

common->revertframes = NULL;

executed (the execution status of this line is deduced): common->revertframes = ((void *)0);

6440

common->wordboundary = NULL;

executed (the execution status of this line is deduced): common->wordboundary = ((void *)0);

6441

common->anynewline = NULL;

executed (the execution status of this line is deduced): common->anynewline = ((void *)0);

6442

common->hspace = NULL;

executed (the execution status of this line is deduced): common->hspace = ((void *)0);

6443

common->vspace = NULL;

executed (the execution status of this line is deduced): common->vspace = ((void *)0);

6444

common->casefulcmp = NULL;

executed (the execution status of this line is deduced): common->casefulcmp = ((void *)0);

6445

common->caselesscmp = NULL;

executed (the execution status of this line is deduced): common->caselesscmp = ((void *)0);

6446

common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;

executed (the execution status of this line is deduced): common->jscript_compat = (re->options & 0x02000000) != 0;

6447 #ifdef SUPPORT_UTF -

6448 /* PCRE_UTF16 has the same value as PCRE_UTF8. */ -

6449

common->utf = (re->options & PCRE_UTF8) != 0;

executed (the execution status of this line is deduced): common->utf = (re->options & 0x00000800) != 0;

6450 #ifdef SUPPORT_UCP -

6451

common->use_ucp = (re->options & PCRE_UCP) != 0;

executed (the execution status of this line is deduced): common->use_ucp = (re->options & 0x20000000) != 0;

6452 #endif -

6453

common->utfreadchar = NULL;

executed (the execution status of this line is deduced): common->utfreadchar = ((void *)0);

6454 #ifdef COMPILE_PCRE8 -

6455 common->utfreadtype8 = NULL; -

6456 #endif -

6457 #endif /* SUPPORT_UTF */ -

6458 #ifdef SUPPORT_UCP -

6459

common->getucd = NULL;

executed (the execution status of this line is deduced): common->getucd = ((void *)0);

6460 #endif -

6461

ccend = bracketend(rootfallback.cc);

executed (the execution status of this line is deduced): ccend = bracketend(rootfallback.cc);

6462

SLJIT_ASSERT(*rootfallback.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);

executed: }

Execution Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6463

common->localsize = get_localspace(common, rootfallback.cc, ccend);

executed (the execution status of this line is deduced): common->localsize = get_localspace(common, rootfallback.cc, ccend);

6464

if (common->localsize < 0)

partially evaluated: common->localsize < 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6465

common->localsize += common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w);

never executed: return;

6466

executed (the execution status of this line is deduced): common->localsize += common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w);

6467

if (common->localsize > SLJIT_MAX_LOCAL_SIZE)

partially evaluated: common->localsize > 65536

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6468

common->localptrs = (int*)SLJIT_MALLOC((ccend - rootfallback.cc) * sizeof(int));

never executed: return;

6469

executed (the execution status of this line is deduced): common->localptrs = (int*)(pcre16_malloc)((ccend - rootfallback.cc) * sizeof(int));

6470

if (!common->localptrs)

partially evaluated: !common->localptrs

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6471

memset(common->localptrs, 0, (ccend - rootfallback.cc) * sizeof(int));

never executed: return;

6472

executed (the execution status of this line is deduced): memset(common->localptrs, 0, (ccend - rootfallback.cc) * sizeof(int));

6473

set_localptrs(common, common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w), ccend);

executed (the execution status of this line is deduced): set_localptrs(common, common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w), ccend);

6474 -

6475

compiler = sljit_create_compiler();

executed (the execution status of this line is deduced): compiler = sljit_create_compiler();

6476

if (!compiler)

partially evaluated: !compiler

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6477 { -

6478

never executed (the execution status of this line is deduced): (pcre16_free)(common->localptrs);

6479

common->compiler = compiler;

never executed: return;

6480 } -

6481

executed (the execution status of this line is deduced): common->compiler = compiler;

6482 -

6483 /* Main pcre_jit_exec entry. */ -

6484

sljit_emit_enter(compiler, 1, 5, 5, common->localsize);

executed (the execution status of this line is deduced): sljit_emit_enter(compiler, 1, 5, 5, common->localsize);

6485 -

6486 /* Register init. */ -

6487

reset_ovector(common, (re->top_bracket + 1) * 2);

executed (the execution status of this line is deduced): reset_ovector(common, (re->top_bracket + 1) * 2);

6488

if ((re->flags & PCRE_REQCHSET) != 0)

partially evaluated: (re->flags & 0x0040) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6489

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_CHAR_PTR, SLJIT_TEMPORARY_REG1, 0);

never executed: sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((6 * sizeof(sljit_w))), (1), (0));

6490 -

6491

OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_SAVED_REG1, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (9), (0), (6), (0));

6492

OP1(SLJIT_MOV, TMP1, 0, SLJIT_SAVED_REG1, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (6), (0));

6493

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->str) - 0x10)));

6494

OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (7), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->end) - 0x10)));

6495

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->stack) - 0x10)));

6496

OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, calllimit));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (12), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->calllimit) - 0x10)));

6497

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, base));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (3))), (((sljit_w)(&((struct sljit_stack*)0x10)->base) - 0x10)));

6498

OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, limit));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (8), (0), ((0x100 | (3))), (((sljit_w)(&((struct sljit_stack*)0x10)->limit) - 0x10)));

6499

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT, TMP1, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((5 * sizeof(sljit_w))), (1), (0));

6500 -

6501 /* Main part of the matching */ -

6502

if ((re->options & PCRE_ANCHORED) == 0)

partially evaluated: (re->options & 0x00000010) == 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6503 { -

6504

mainloop = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0, (re->options & PCRE_FIRSTLINE) != 0);

executed (the execution status of this line is deduced): mainloop = mainloop_entry(common, (re->flags & 0x0800) != 0, (re->options & 0x00040000) != 0);

6505 /* Forward search if possible. */ -

6506

if ((re->flags & PCRE_FIRSTSET) != 0)

evaluated: (re->flags & 0x0010) != 0

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:9

6-9

6507

fast_forward_first_char(common, re->first_char, (re->flags & PCRE_FCH_CASELESS) != 0, (re->options & PCRE_FIRSTLINE) != 0);

executed: fast_forward_first_char(common, re->first_char, (re->flags & 0x0020) != 0, (re->options & 0x00040000) != 0);

Execution Count:6

6508

else if ((re->flags & PCRE_STARTLINE) != 0)

evaluated: (re->flags & 0x0100) != 0

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:4

4-5

6509

fast_forward_newline(common, (re->options & PCRE_FIRSTLINE) != 0);

executed: fast_forward_newline(common, (re->options & 0x00040000) != 0);

Execution Count:5

6510

else if ((re->flags & PCRE_STARTLINE) == 0 && study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)

partially evaluated: (re->flags & 0x0100) == 0

TRUE	FALSE
yes Evaluation Count:4	no Evaluation Count:0

partially evaluated: study != ((void *)0)

TRUE	FALSE
yes Evaluation Count:4	no Evaluation Count:0

partially evaluated: (study->flags & 0x0001) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4

0-4

6511

fast_forward_start_bits(common, (sljit_uw)study->start_bits, (re->options & PCRE_FIRSTLINE) != 0);

never executed: fast_forward_start_bits(common, (sljit_uw)study->start_bits, (re->options & 0x00040000) != 0);

6512 } -

6513

if ((re->flags & PCRE_REQCHSET) != 0)

partially evaluated: (re->flags & 0x0040) != 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6514

reqbyte_notfound = search_requested_char(common, re->req_char, (re->flags & PCRE_RCH_CASELESS) != 0, (re->flags & PCRE_FIRSTSET) != 0);

never executed: reqbyte_notfound = search_requested_char(common, re->req_char, (re->flags & 0x0080) != 0, (re->flags & 0x0010) != 0);

6515 -

6516 /* Store the current STR_PTR in OVECTOR(0). */ -

6517

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), (6), (0));

6518 /* Copy the limit of allowed recursions. */ -

6519

OP1(SLJIT_MOV, CALL_COUNT, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (10), (0), ((0x100 | (11))), ((5 * sizeof(sljit_w))));

6520 -

6521

compile_hotpath(common, rootfallback.cc, ccend, &rootfallback);

executed (the execution status of this line is deduced): compile_hotpath(common, rootfallback.cc, ccend, &rootfallback);

6522

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6523 { -

6524

never executed (the execution status of this line is deduced): sljit_free_compiler(compiler);

6525

never executed (the execution status of this line is deduced): (pcre16_free)(common->localptrs);

6526

empty_match = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));

never executed: return;

6527 } -

6528 -

6529

executed (the execution status of this line is deduced):

empty_match = sljit_emit_cmp(compiler, (0), (6), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))));

6530

empty_match_found = LABEL();

executed (the execution status of this line is deduced): empty_match_found = sljit_emit_label(compiler);

6531 -

6532

common->acceptlabel = LABEL();

executed (the execution status of this line is deduced): common->acceptlabel = sljit_emit_label(compiler);

6533

if (common->accept != NULL)

partially evaluated: common->accept != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6534

set_jumps(common->accept, common->acceptlabel);

never executed: set_jumps(common->accept, common->acceptlabel);

6535 -

6536 /* This means we have a match. Update the ovector. */ -

6537

copy_ovector(common, re->top_bracket + 1);

executed (the execution status of this line is deduced): copy_ovector(common, re->top_bracket + 1);

6538

leave = LABEL();

executed (the execution status of this line is deduced): leave = sljit_emit_label(compiler);

6539

sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);

executed (the execution status of this line is deduced): sljit_emit_return(compiler, 6, 1, 0);

6540 -

6541

empty_match_fallback = LABEL();

executed (the execution status of this line is deduced): empty_match_fallback = sljit_emit_label(compiler);

6542

compile_fallbackpath(common, rootfallback.top);

executed (the execution status of this line is deduced): compile_fallbackpath(common, rootfallback.top);

6543

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

partially evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6544 { -

6545

never executed (the execution status of this line is deduced): sljit_free_compiler(compiler);

6546

never executed (the execution status of this line is deduced): (pcre16_free)(common->localptrs);

6547

SLJIT_ASSERT(rootfallback.prev == NULL);

never executed: return;

6548 } -

6549 -

6550

executed: }

Execution Count:15

partially evaluated: 0

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6551 -

6552 /* Check we have remaining characters. */ -

6553

OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (6), (0), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))));

6554 -

6555

if ((re->options & PCRE_ANCHORED) == 0)

partially evaluated: (re->options & 0x00000010) == 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6556 { -

6557

if ((re->options & PCRE_FIRSTLINE) == 0)

partially evaluated: (re->options & 0x00040000) == 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6558 { -

6559

if (study != NULL && study->minlength > 1)

partially evaluated: study != ((void *)0)

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

partially evaluated: study->minlength > 1

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6560 { -

6561

OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (6), (0), (0x200), (((study->minlength) << 1)));

6562

CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_END, 0, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (5), (1), (0), (7), (0)), (mainloop));

6563

CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);

never executed: }

6564 else -

6565

executed: sljit_set_label(sljit_emit_cmp(compiler, (2), (6), (0), (7), (0)), (mainloop));

Execution Count:15

6566 } -

6567 else -

6568 { -

6569

if (study != NULL && study->minlength > 1)

never evaluated: study != ((void *)0)

never evaluated: study->minlength > 1

6570 { -

6571

OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength));

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (23), (1), (0), (6), (0), (0x200), (((study->minlength) << 1)));

6572

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, STR_END, 0);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (1), (0), (7), (0));

6573

COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (6), (3), (0), (4));

6574

OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);

never executed (the execution status of this line is deduced): sljit_emit_op2(compiler, (25 | 0x0800), (0), (0), (6), (0), ((0x100 | (11))), ((7 * sizeof(sljit_w))));

6575

COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_GREATER_EQUAL);

never executed (the execution status of this line is deduced): sljit_emit_cond_value(compiler, (29 | 0x0200), (3), (0), (3));

6576

JUMPTO(SLJIT_C_ZERO, mainloop);

never executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (0)), (mainloop));

6577

CMPTO(SLJIT_C_LESS, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, mainloop);

never executed: }

6578 else -

6579

never executed: sljit_set_label(sljit_emit_cmp(compiler, (2), (6), (0), ((0x100 | (11))), ((7 * sizeof(sljit_w)))), (mainloop));

6580 } -

6581 } -

6582 -

6583

if (reqbyte_notfound != NULL)

partially evaluated: reqbyte_notfound != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6584

JUMPHERE(reqbyte_notfound);

never executed: sljit_set_label((reqbyte_notfound), sljit_emit_label(compiler));

6585 /* Copy OVECTOR(1) to OVECTOR(0) */ -

6586

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));

executed (the execution status of this line is deduced):

sljit_emit_op1(compiler, (6), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (0) * sizeof(sljit_w))), ((0x100 | (11))), (((8 * sizeof(sljit_w)) + (1) * sizeof(sljit_w))));

6587

OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), ((-1)));

6588

JUMPTO(SLJIT_JUMP, leave);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (leave));

6589 -

6590

flush_stubs(common);

executed (the execution status of this line is deduced): flush_stubs(common);

6591 -

6592

JUMPHERE(empty_match);

executed (the execution status of this line is deduced): sljit_set_label((empty_match), sljit_emit_label(compiler));

6593

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

6594

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->notempty) - 0x10)));

6595

CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_fallback);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (3), (0), (0x200), (0)), (empty_match_fallback));

6596

OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));

executed (the execution status of this line is deduced):

sljit_emit_op1(compiler, (7), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->notempty_atstart) - 0x10)));

6597

CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (0), (3), (0), (0x200), (0)), (empty_match_found));

6598

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->str) - 0x10)));

6599

CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_cmp(compiler, (1), (3), (0), (6), (0)), (empty_match_found));

6600

JUMPTO(SLJIT_JUMP, empty_match_fallback);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (empty_match_fallback));

6601 -

6602

common->currententry = common->entries;

executed (the execution status of this line is deduced): common->currententry = common->entries;

6603

while (common->currententry != NULL)

partially evaluated: common->currententry != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6604 { -

6605 /* Might add new entries. */ -

6606

compile_recurse(common);

never executed (the execution status of this line is deduced): compile_recurse(common);

6607

if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))

never evaluated: __builtin_expect((sljit_get_compiler_error(compiler)), 0)

6608 { -

6609

never executed (the execution status of this line is deduced): sljit_free_compiler(compiler);

6610

never executed (the execution status of this line is deduced): (pcre16_free)(common->localptrs);

6611

common->currententry = common->currententry->next;

never executed: return;

6612 } -

6613

flush_stubs(common);

never executed (the execution status of this line is deduced): flush_stubs(common);

6614

never executed (the execution status of this line is deduced): common->currententry = common->currententry->next;

6615

set_jumps(common->stackalloc, LABEL());

never executed: }

6616 -

6617 /* Allocating stack, returns with PCRE_ERROR_JIT_STACKLIMIT if fails. */ -

6618 /* This is a (really) rare case. */ -

6619

executed (the execution status of this line is deduced): set_jumps(common->stackalloc, sljit_emit_label(compiler));

6620 /* RETURN_ADDR is not a saved register. */ -

6621

sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);

executed (the execution status of this line is deduced): sljit_emit_fast_enter(compiler, (0x100 | (11)), (0 * sizeof(sljit_w)), 1, 5, 5, common->localsize);

6622

OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (11))), ((1 * sizeof(sljit_w))), (3), (0));

6623

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

6624

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->stack) - 0x10)));

6625

OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top), STACK_TOP, 0);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), ((0x100 | (1))), (((sljit_w)(&((struct sljit_stack*)0x10)->top) - 0x10)), (2), (0));

6626

OP2(SLJIT_ADD, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit), SLJIT_IMM, STACK_GROWTH_RATE);

executed (the execution status of this line is deduced):

sljit_emit_op2(compiler, (23), (3), (0), ((0x100 | (1))), (((sljit_w)(&((struct sljit_stack*)0x10)->limit) - 0x10)), (0x200), (8192));

6627 -

6628

sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize));

executed (the execution status of this line is deduced): sljit_emit_ijump(compiler, 26, 0x200, ((sljit_w)sljit_stack_resize));

6629

alloc_error = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);

executed (the execution status of this line is deduced): alloc_error = sljit_emit_cmp(compiler, (1), (1), (0), (0x200), (0));

6630

OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (9), (0));

6631

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), ((0x100 | (1))), (((sljit_w)(&((jit_arguments*)0x10)->stack) - 0x10)));

6632

OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (2), (0), ((0x100 | (1))), (((sljit_w)(&((struct sljit_stack*)0x10)->top) - 0x10)));

6633

OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit));

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (8), (0), ((0x100 | (1))), (((sljit_w)(&((struct sljit_stack*)0x10)->limit) - 0x10)));

6634

OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (3), (0), ((0x100 | (11))), ((1 * sizeof(sljit_w))));

6635

sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);

executed (the execution status of this line is deduced): sljit_emit_fast_return(compiler, (0x100 | (11)), (0 * sizeof(sljit_w)));

6636 -

6637 /* Allocation failed. */ -

6638

JUMPHERE(alloc_error);

executed (the execution status of this line is deduced): sljit_set_label((alloc_error), sljit_emit_label(compiler));

6639 /* We break the return address cache here, but this is a really rare case. */ -

6640

OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_JIT_STACKLIMIT);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), ((-27)));

6641

JUMPTO(SLJIT_JUMP, leave);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (leave));

6642 -

6643 /* Call limit reached. */ -

6644

set_jumps(common->calllimit, LABEL());

executed (the execution status of this line is deduced): set_jumps(common->calllimit, sljit_emit_label(compiler));

6645

OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_MATCHLIMIT);

executed (the execution status of this line is deduced): sljit_emit_op1(compiler, (6), (1), (0), (0x200), ((-8)));

6646

JUMPTO(SLJIT_JUMP, leave);

executed (the execution status of this line is deduced): sljit_set_label(sljit_emit_jump(compiler, (22)), (leave));

6647 -

6648

if (common->revertframes != NULL)

partially evaluated: common->revertframes != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6649 { -

6650

set_jumps(common->revertframes, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->revertframes, sljit_emit_label(compiler));

6651

do_revertframes(common);

never executed (the execution status of this line is deduced): do_revertframes(common);

6652

if (common->wordboundary != NULL)

never executed: }

6653

evaluated: common->wordboundary != ((void *)0)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:14

1-14

6654 { -

6655

set_jumps(common->wordboundary, LABEL());

executed (the execution status of this line is deduced): set_jumps(common->wordboundary, sljit_emit_label(compiler));

6656

check_wordboundary(common);

executed (the execution status of this line is deduced): check_wordboundary(common);

6657

if (common->anynewline != NULL)

executed: }

Execution Count:1

6658

partially evaluated: common->anynewline != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6659 { -

6660

set_jumps(common->anynewline, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->anynewline, sljit_emit_label(compiler));

6661

check_anynewline(common);

never executed (the execution status of this line is deduced): check_anynewline(common);

6662

if (common->hspace != NULL)

never executed: }

6663

partially evaluated: common->hspace != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6664 { -

6665

set_jumps(common->hspace, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->hspace, sljit_emit_label(compiler));

6666

check_hspace(common);

never executed (the execution status of this line is deduced): check_hspace(common);

6667

if (common->vspace != NULL)

never executed: }

6668

partially evaluated: common->vspace != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6669 { -

6670

set_jumps(common->vspace, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->vspace, sljit_emit_label(compiler));

6671

check_vspace(common);

never executed (the execution status of this line is deduced): check_vspace(common);

6672

if (common->casefulcmp != NULL)

never executed: }

6673

partially evaluated: common->casefulcmp != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6674 { -

6675

set_jumps(common->casefulcmp, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->casefulcmp, sljit_emit_label(compiler));

6676

do_casefulcmp(common);

never executed (the execution status of this line is deduced): do_casefulcmp(common);

6677

if (common->caselesscmp != NULL)

never executed: }

6678

partially evaluated: common->caselesscmp != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6679 { -

6680

set_jumps(common->caselesscmp, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->caselesscmp, sljit_emit_label(compiler));

6681

do_caselesscmp(common);

never executed (the execution status of this line is deduced): do_caselesscmp(common);

6682

if (common->utfreadchar != NULL)

never executed: }

6683 #ifdef SUPPORT_UTF -

6684

evaluated: common->utfreadchar != ((void *)0)

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:8

7-8

6685 { -

6686

set_jumps(common->utfreadchar, LABEL());

executed (the execution status of this line is deduced): set_jumps(common->utfreadchar, sljit_emit_label(compiler));

6687

do_utfreadchar(common);

executed (the execution status of this line is deduced): do_utfreadchar(common);

6688

if (common->getucd != NULL)

executed: }

Execution Count:7

6689 #ifdef COMPILE_PCRE8 -

6690 if (common->utfreadtype8 != NULL) -

6691 { -

6692 set_jumps(common->utfreadtype8, LABEL()); -

6693 do_utfreadtype8(common); -

6694 } -

6695 #endif -

6696 #endif /* COMPILE_PCRE8 */ -

6697 #ifdef SUPPORT_UCP -

6698

partially evaluated: common->getucd != ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6699 { -

6700

set_jumps(common->getucd, LABEL());

never executed (the execution status of this line is deduced): set_jumps(common->getucd, sljit_emit_label(compiler));

6701

do_getucd(common);

never executed (the execution status of this line is deduced): do_getucd(common);

6702

never executed: }

6703 #endif -

6704 -

6705

executable_func = sljit_generate_code(compiler);

executed (the execution status of this line is deduced): (pcre16_free)(common->localptrs);

6706

executed (the execution status of this line is deduced): executable_func = sljit_generate_code(compiler);

6707

executable_size = sljit_get_generated_code_size(compiler);

executed (the execution status of this line is deduced): executable_size = sljit_get_generated_code_size(compiler);

6708

if (executable_func == NULL)

executed (the execution status of this line is deduced): sljit_free_compiler(compiler);

6709

partially evaluated: executable_func == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6710

function = SLJIT_MALLOC(sizeof(executable_function));

never executed: return;

6711 -

6712

executed (the execution status of this line is deduced): function = (pcre16_malloc)(sizeof(executable_function));

6713

if (function == NULL)

partially evaluated: function == ((void *)0)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:15

0-15

6714 { -

6715 /* This case is highly unlikely since we just recently -

6716 freed a lot of memory. Although not impossible. */ -

6717

sljit_free_code(executable_func);

never executed (the execution status of this line is deduced): sljit_free_code(executable_func);

6718

function->executable_func = executable_func;

never executed: return;

6719 } -

6720 -

6721

executed (the execution status of this line is deduced): function->executable_func = executable_func;

6722

function->executable_size = executable_size;

executed (the execution status of this line is deduced): function->executable_size = executable_size;

6723

function->callback = NULL;

executed (the execution status of this line is deduced): function->callback = ((void *)0);

6724

function->userdata = NULL;

executed (the execution status of this line is deduced): function->userdata = ((void *)0);

6725

extra->executable_jit = function;

executed (the execution status of this line is deduced): extra->executable_jit = function;

6726

extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;

executed (the execution status of this line is deduced): extra->flags |= 0x0040;

6727

jit_function call_executable_func;

executed: }

Execution Count:15

6728 -

6729 static int jit_machine_stack_exec(jit_arguments *arguments, executable_function *function) -

6730 { -

6731

union {

executed (the execution status of this line is deduced): union {

6732

void* executable_func;

executed (the execution status of this line is deduced): void* executable_func;

6733

executed (the execution status of this line is deduced): jit_function call_executable_func;

6734

} convert_executable_func;

executed (the execution status of this line is deduced): } convert_executable_func;

6735

pcre_uint8 local_area[LOCAL_SPACE_SIZE];

executed (the execution status of this line is deduced): pcre_uint8 local_area[32768];

6736

struct sljit_stack local_stack;

executed (the execution status of this line is deduced): struct sljit_stack local_stack;

6737 -

6738

local_stack.top = (sljit_w)&local_area;

executed (the execution status of this line is deduced): local_stack.top = (sljit_w)&local_area;

6739

local_stack.base = local_stack.top;

executed (the execution status of this line is deduced): local_stack.base = local_stack.top;

6740

local_stack.limit = local_stack.base + LOCAL_SPACE_SIZE;

executed (the execution status of this line is deduced): local_stack.limit = local_stack.base + 32768;

6741

local_stack.max_limit = local_stack.limit;

executed (the execution status of this line is deduced): local_stack.max_limit = local_stack.limit;

6742

arguments->stack = &local_stack;

executed (the execution status of this line is deduced): arguments->stack = &local_stack;

6743

convert_executable_func.executable_func = function->executable_func;

executed (the execution status of this line is deduced): convert_executable_func.executable_func = function->executable_func;

6744

return convert_executable_func.call_executable_func(arguments);

executed: return convert_executable_func.call_executable_func(arguments);

Execution Count:172

172

6745 } -

6746 -

6747 int -

6748 PRIV(jit_exec)(const REAL_PCRE *re, void *executable_func, -

6749 const pcre_uchar *subject, int length, int start_offset, int options, -

6750 int match_limit, int *offsets, int offsetcount) -

6751 { -

6752

executable_function *function = (executable_function*)executable_func;

executed (the execution status of this line is deduced): executable_function *function = (executable_function*)executable_func;

6753

union {

executed (the execution status of this line is deduced): union {

6754

void* executable_func;

executed (the execution status of this line is deduced): void* executable_func;

6755

jit_function call_executable_func;

executed (the execution status of this line is deduced): jit_function call_executable_func;

6756

} convert_executable_func;

executed (the execution status of this line is deduced): } convert_executable_func;

6757

jit_arguments arguments;

executed (the execution status of this line is deduced): jit_arguments arguments;

6758

int maxoffsetcount;

executed (the execution status of this line is deduced): int maxoffsetcount;

6759

int retval;

executed (the execution status of this line is deduced): int retval;

6760 -

6761 /* Sanity checks should be handled by pcre_exec. */ -

6762

arguments.stack = NULL;

executed (the execution status of this line is deduced): arguments.stack = ((void *)0);

6763

arguments.str = subject + start_offset;

executed (the execution status of this line is deduced): arguments.str = subject + start_offset;

6764

arguments.begin = subject;

executed (the execution status of this line is deduced): arguments.begin = subject;

6765

arguments.end = subject + length;

executed (the execution status of this line is deduced): arguments.end = subject + length;

6766

arguments.calllimit = match_limit; /* JIT decreases this value less times. */

executed (the execution status of this line is deduced): arguments.calllimit = match_limit;

6767

arguments.notbol = (options & PCRE_NOTBOL) != 0;

executed (the execution status of this line is deduced): arguments.notbol = (options & 0x00000080) != 0;

6768

arguments.noteol = (options & PCRE_NOTEOL) != 0;

executed (the execution status of this line is deduced): arguments.noteol = (options & 0x00000100) != 0;

6769

arguments.notempty = (options & PCRE_NOTEMPTY) != 0;

executed (the execution status of this line is deduced): arguments.notempty = (options & 0x00000400) != 0;

6770

arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;

executed (the execution status of this line is deduced): arguments.notempty_atstart = (options & 0x10000000) != 0;

6771

arguments.offsets = offsets;

executed (the execution status of this line is deduced): arguments.offsets = offsets;

6772 -

6773 /* pcre_exec() rounds offsetcount to a multiple of 3, and then uses only 2/3 of -

6774 the output vector for storing captured strings, with the remainder used as -

6775 workspace. We don't need the workspace here. For compatibility, we limit the -

6776 number of captured strings in the same way as pcre_exec(), so that the user -

6777 gets the same result with and without JIT. */ -

6778 -

6779

if (offsetcount != 2)

partially evaluated: offsetcount != 2

TRUE	FALSE
yes Evaluation Count:172	no Evaluation Count:0

0-172

6780

offsetcount = ((offsetcount - (offsetcount % 3)) * 2) / 3;

executed: offsetcount = ((offsetcount - (offsetcount % 3)) * 2) / 3;

Execution Count:172

172

6781

maxoffsetcount = (re->top_bracket + 1) * 2;

executed (the execution status of this line is deduced): maxoffsetcount = (re->top_bracket + 1) * 2;

6782

if (offsetcount > maxoffsetcount)

partially evaluated: offsetcount > maxoffsetcount

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:172

0-172

6783

offsetcount = maxoffsetcount;

never executed: offsetcount = maxoffsetcount;

6784

arguments.offsetcount = offsetcount;

executed (the execution status of this line is deduced): arguments.offsetcount = offsetcount;

6785 -

6786

if (function->callback)

partially evaluated: function->callback

TRUE	FALSE
yes Evaluation Count:172	no Evaluation Count:0

0-172

6787

arguments.stack = (struct sljit_stack*)function->callback(function->userdata);

executed: arguments.stack = (struct sljit_stack*)function->callback(function->userdata);

Execution Count:172

172

6788 else -

6789

arguments.stack = (struct sljit_stack*)function->userdata;

never executed: arguments.stack = (struct sljit_stack*)function->userdata;

6790 -

6791

if (arguments.stack == NULL)

partially evaluated: arguments.stack == ((void *)0)

TRUE	FALSE
yes Evaluation Count:172	no Evaluation Count:0

0-172

6792

retval = jit_machine_stack_exec(&arguments, function);

executed: retval = jit_machine_stack_exec(&arguments, function);

Execution Count:172

172

6793 else -

6794 { -

6795

convert_executable_func.executable_func = function->executable_func;

never executed (the execution status of this line is deduced): convert_executable_func.executable_func = function->executable_func;

6796

retval = convert_executable_func.call_executable_func(&arguments);

never executed (the execution status of this line is deduced): retval = convert_executable_func.call_executable_func(&arguments);

6797

if (retval * 2 > offsetcount)

never executed: }

6798 -

6799

partially evaluated: retval * 2 > offsetcount

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:172

0-172

6800

retval = 0;

never executed: retval = 0;

6801

return retval;

executed: return retval;

Execution Count:172

172

6802 } -

6803 -

6804 void -

6805 PRIV(jit_free)(void *executable_func) -

6806 { -

6807

executable_function *function = (executable_function*)executable_func;

executed (the execution status of this line is deduced): executable_function *function = (executable_function*)executable_func;

6808

sljit_free_code(function->executable_func);

executed (the execution status of this line is deduced): sljit_free_code(function->executable_func);

6809

SLJIT_FREE(function);

executed (the execution status of this line is deduced): (pcre16_free)(function);

6810

return ((executable_function*)executable_func)->executable_size;

executed: }

Execution Count:15

6811 -

6812 int -

6813 PRIV(jit_get_size)(void *executable_func) -

6814 { -

6815

never executed: return ((executable_function*)executable_func)->executable_size;

6816 } -

6817 -

6818 const char* -

6819 PRIV(jit_get_target)(void) -

6820 { -

6821

return sljit_get_platform_name();

never executed: return sljit_get_platform_name();

6822 } -

6823 -

6824 #ifdef COMPILE_PCRE8 -

6825 PCRE_EXP_DECL pcre_jit_stack * -

6826 pcre_jit_stack_alloc(int startsize, int maxsize) -

6827 #else -

6828 PCRE_EXP_DECL pcre16_jit_stack * -

6829 pcre16_jit_stack_alloc(int startsize, int maxsize) -

6830 #endif -

6831 { -

6832

if (startsize < 1 || maxsize < 1)

never evaluated: startsize < 1

never evaluated: maxsize < 1

6833

startsize = (startsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);

never executed: return ((void *)0);

6834

if (startsize > maxsize)

never evaluated: startsize > maxsize

6835

startsize = maxsize;

never executed: startsize = maxsize;

6836

never executed (the execution status of this line is deduced): startsize = (startsize + 8192 - 1) & ~(8192 - 1);

6837

maxsize = (maxsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);

never executed (the execution status of this line is deduced): maxsize = (maxsize + 8192 - 1) & ~(8192 - 1);

6838

return (PUBL(jit_stack)*)sljit_allocate_stack(startsize, maxsize);

never executed: return (pcre16_jit_stack*)sljit_allocate_stack(startsize, maxsize);

6839 } -

6840 -

6841 #ifdef COMPILE_PCRE8 -

6842 PCRE_EXP_DECL void -

6843 pcre_jit_stack_free(pcre_jit_stack *stack) -

6844 #else -

6845 PCRE_EXP_DECL void -

6846 pcre16_jit_stack_free(pcre16_jit_stack *stack) -

6847 #endif -

6848 { -

6849

sljit_free_stack((struct sljit_stack*)stack);

never executed (the execution status of this line is deduced): sljit_free_stack((struct sljit_stack*)stack);

6850

executable_function *function;

never executed: }

6851 -

6852 #ifdef COMPILE_PCRE8 -

6853 PCRE_EXP_DECL void -

6854 pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata) -

6855 #else -

6856 PCRE_EXP_DECL void -

6857 pcre16_assign_jit_stack(pcre16_extra *extra, pcre16_jit_callback callback, void *userdata) -

6858 #endif -

6859 { -

6860

executed (the execution status of this line is deduced): executable_function *function;

6861

if (extra != NULL &&

partially evaluated: extra != ((void *)0)

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6862

(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&

partially evaluated: (extra->flags & 0x0040) != 0

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6863

extra->executable_jit != NULL)

partially evaluated: extra->executable_jit != ((void *)0)

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-15

6864 { -

6865

function = (executable_function*)extra->executable_jit;

executed (the execution status of this line is deduced): function = (executable_function*)extra->executable_jit;

6866

function->callback = callback;

executed (the execution status of this line is deduced): function->callback = callback;

6867

function->userdata = userdata;

executed (the execution status of this line is deduced): function->userdata = userdata;

6868

executed: }

Execution Count:15

6869