BitVecAnd

Documentation

API Reference

BitVecAnd

Description

Perform bitwise AND operation between two bitvectors. Result is stored in result. Operand lengths must match.

Parameters

Name	Direction	Description
`result`	out	Bitvector to store result in. Pre-sized to the operand length by the helper if needed.
`a`	in	First bitvector operand.
`b`	in	Second bitvector operand.

Usage example (from documentation)

  BitVecAnd(&result, &flags1, &flags2);

Success

Returns to the caller. result->length == a->length; each bit result[i] == a[i] & b[i]. The operands a and b are unchanged.

Failure

Function cannot fail in an observable way - mismatched operand lengths or invalid bitvectors are caller bugs and abort via LOG_FATAL.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:531:

    }
    
    void BitVecAnd(BitVec *result, BitVec *a, BitVec *b) {
        ValidateBitVec(result);
        ValidateBitVec(a);

In BitVec.BitWise.Simple.c:35:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecAnd\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:54:

    
        // Perform AND operation
        BitVecAnd(&result, &bv1, &bv2);
    
        // Expected result: 1000 (1101 AND 1010)

In BitVec.BitWise.Simple.c:452:

        // Test operations on empty bitvecs
        BitVec result_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (BitVecLen(&result_bv) == 0);

In BitVec.BitWise.Simple.c:463:

        BitVecPush(&bv2, false);
    
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (BitVecLen(&result_bv) >= 1); // Should handle gracefully

In BitVec.BitWise.Simple.c:541:

    
        // Test AND with different lengths (result should be min length)
        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (BitVecLen(&result) == 4);

In BitVec.BitWise.Simple.c:558:

        BitVecPush(&bv2, false);
    
        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (BitVecLen(&result) == 1);
        test_result = test_result && (BitVecGet(&result, 0) == false);

In BitVec.BitWise.Simple.c:739:

    
        // Test A AND A = A
        BitVecAnd(&result, &bv1, &bv1);
        bool and_identity = true;
        for (int i = 0; i < 16; i++) {

In BitVec.BitWise.Simple.c:786:

        }
    
        BitVecAnd(&result, &bv1, &bv2);
        bool and_zero = true;
        for (int i = 0; i < 16; i++) {

In BitVec.BitWise.Simple.c:838:

    
        // Test A AND B = B AND A
        BitVecAnd(&result1, &bv1, &bv2);
        BitVecAnd(&result2, &bv2, &bv1);

In BitVec.BitWise.Simple.c:839:

        // Test A AND B = B AND A
        BitVecAnd(&result1, &bv1, &bv2);
        BitVecAnd(&result2, &bv2, &bv1);
    
        bool and_commutative = true;

In BitVec.BitWise.Simple.c:902:

    
        // Test AND on large data
        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (BitVecLen(&result) == 1000);

In BitVec.BitWise.Deadend.c:40:

    
        // Test NULL pointer - should abort
        BitVecAnd(NULL, &bv, &bv2);
    
        BitVecDeinit(&bv);

In BitVec.BitWise.Deadend.c:87:

    
        // Test NULL result pointer - should abort
        BitVecAnd(NULL, &bv1, &bv2);
    
        BitVecDeinit(&bv1);

In BitVec.BitWise.c:35:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmtLn("Testing BitVecAnd");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.c:54:

    
        // Perform AND operation
        BitVecAnd(&result, &bv1, &bv2);
    
        // Expected result: 1000 (1101 AND 1010)

In BitVec.BitWise.c:452:

        // Test operations on empty bitvecs
        BitVec result_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (BitVecLen(&result_bv) == 0);

In BitVec.BitWise.c:463:

        BitVecPush(&bv2, false);
    
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (BitVecLen(&result_bv) >= 1); // Should handle gracefully

In BitVec.BitWise.c:541:

    
        // Test AND with different lengths (result should be min length)
        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (BitVecLen(&result) == 4);

In BitVec.BitWise.c:558:

        BitVecPush(&bv2, false);
    
        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (BitVecLen(&result) == 1);
        test_result = test_result && (BitVecGet(&result, 0) == false);

In BitVec.BitWise.c:739:

    
        // Test A AND A = A
        BitVecAnd(&result, &bv1, &bv1);
        bool and_identity = true;
        for (int i = 0; i < 16; i++) {

In BitVec.BitWise.c:786:

        }
    
        BitVecAnd(&result, &bv1, &bv2);
        bool and_zero = true;
        for (int i = 0; i < 16; i++) {

In BitVec.BitWise.c:838:

    
        // Test A AND B = B AND A
        BitVecAnd(&result1, &bv1, &bv2);
        BitVecAnd(&result2, &bv2, &bv1);

In BitVec.BitWise.c:839:

        // Test A AND B = B AND A
        BitVecAnd(&result1, &bv1, &bv2);
        BitVecAnd(&result2, &bv2, &bv1);
    
        bool and_commutative = true;

In BitVec.BitWise.c:902:

    
        // Test AND on large data
        BitVecAnd(&result, &bv1, &bv2);
        test_result = test_result && (BitVecLen(&result) == 1000);

In BitVec.BitWise.c:967:

    
        // Test NULL pointer - should abort
        BitVecAnd(NULL, &bv, &bv2);
    
        BitVecDeinit(&bv);

In BitVec.BitWise.c:1014:

    
        // Test NULL result pointer - should abort
        BitVecAnd(NULL, &bv1, &bv2);
    
        BitVecDeinit(&bv1);

Last updated on June 4, 2026

BitVecAllocator BitVecAny