OpenVX CTS: GCC 13 -O3 miscompiles test_array.c -> 5 Array.vxCreateArray baseline failures

[kiritigowda]

Summary

Building the OpenVX Conformance Test Suite (CTS) harness with amdclang at -O3 miscompiles test_conformance/test_array.c, causing 5 baseline conformance tests to fail:

[ FAILED   ] Array.vxCreateArray/0/array/VX_TYPE_CHAR
[ FAILED   ] Array.vxCreateArray/1/array/VX_TYPE_INT8
[ FAILED   ] Array.vxCreateArray/2/array/VX_TYPE_UINT8
[ FAILED   ] Array.vxCreateArray/3/array/VX_TYPE_INT16
[ FAILED   ] Array.vxCreateArray/4/array/VX_TYPE_UINT16

Each fails at test_array.c:459 with:

FAILED at .../OpenVX-cts/test_conformance/test_array.c:459
	Expected: 0 == res
	Actual: 0 != 1

Line 459 is the post-round-trip data check: own_verify_data_items() returns 1 (data mismatch) after vxAddArrayItems + vxMapArrayRange. Only the 1- and 2-byte item types (CHAR, INT8, UINT8, INT16, UINT16) fail; all >= 4-byte types pass.

This is a distinct issue from #1707 (that was HafCpu_ChannelCopy_U8_U8 in libopenvx, fixed by -fno-vectorize). This failure is in the CTS harness translation unit itself, and the -fno-vectorize workaround on libopenvx does not address it.

Root cause — isolated to a single variable

Holding libopenvx.so byte-identical and changing only the optimization level of the CTS harness:

CTS harness build	Array.vxCreateArray result
-O3	5 FAILED (CHAR/INT8/UINT8/INT16/UINT16)
-O2	20 passed
-O1	20 passed
-O0	20 passed

Further isolation: with the whole harness at -O2 and only test_array.c recompiled at -O3, the 5 tests fail again → the miscompiled translation unit is test_array.c, trigger is -O3.

The optimization level and flags of libopenvx (tried -O3/-O2/-O1, with and without -fno-vectorize / -fno-slp-vectorize) make no difference — the failure tracks the CTS harness opt level only. Fails on both AGO_DEFAULT_TARGET=CPU and GPU.

Reproduction

# 1. Build MIVisionX (HIP backend), defaults:
mkdir build && cd build
cmake .. -DBACKEND=HIP
make -j$(nproc)
cd ..

# 2. Build the CTS with plain defaults (Release => -O3; amdclang does NOT hit the
#    GNUCC-only -O3->-O2 downgrade in OpenVX-cts/cmake/openvx.cmake), then run:
git clone --depth 1 -b openvx_1.3.2 https://github.com/KhronosGroup/OpenVX-cts.git
cd OpenVX-cts && git lfs pull && mkdir build && cd build
cmake .. \
  -DOPENVX_INCLUDES="$PWD/../../amd_openvx/openvx/include" \
  -DOPENVX_LIBRARIES="$PWD/../../build/lib/libopenvx.so;$PWD/../../build/lib/libvxu.so;pthread;dl;m;rt" \
  -DOPENVX_CONFORMANCE_VISION=ON -DCMAKE_POLICY_VERSION_MINIMUM=3.5
make -j$(nproc)
VX_TEST_DATA_PATH=../test_data/ ./bin/vx_test_conformance --filter='Array.vxCreateArray*'

Workaround (confirmed): build the CTS at -O2 — either via the -O3 -> -O2 string replace in OpenVX-cts/cmake/openvx.cmake, or by forcing -DCMAKE_C_FLAGS_RELEASE="-O2 -DNDEBUG" -DCMAKE_CXX_FLAGS_RELEASE="-O2 -DNDEBUG". This is what .github/workflows/conformance-hip.yml already does; the failure surfaces when the CTS is built at its default -O3 (e.g. PR #1746).

Results (local repro)

• Toolchain: AMD clang version 23.0.0git (ROCm/llvm-project 43215c73...), ROCm 7.13
• GPU: gfx1151 (also reproduced in CI on gfx950 / ROCm 10.1-nightly, PR-1746)
• MIVisionX: develop @ b880c796, CTS branch openvx_1.3.2

Same libopenvx.so, only the harness opt level changed:

### CTS built at -O2 (whole harness)  [libopenvx unchanged]
[ PASSED   ] 20 test(s)
[ FAILED   ] 0 test(s)

### CTS built at -O3 (whole harness)  [same libopenvx]
FAILED at .../OpenVX-cts/test_conformance/test_array.c:459
	Actual: 0 != 1   (x5)
[ PASSED   ] 15 test(s)
[ FAILED   ] 5 test(s), listed below:
[ FAILED   ] Array.vxCreateArray/0/array/VX_TYPE_CHAR
[ FAILED   ] Array.vxCreateArray/1/array/VX_TYPE_INT8
[ FAILED   ] Array.vxCreateArray/2/array/VX_TYPE_UINT8
[ FAILED   ] Array.vxCreateArray/3/array/VX_TYPE_INT16
[ FAILED   ] Array.vxCreateArray/4/array/VX_TYPE_UINT16

Notes for a compiler bug report

The miscompile is whole-translation-unit / IR-shape sensitive: extracting own_alloc_init_data_items() and own_verify_data_items() verbatim into a standalone .c and compiling at -O3 does not reproduce it — the full test_array.c TU is required. A minimal standalone for the LLVM team therefore needs llvm-reduce driven by an interestingness test (recompile test_array.c at -O3, check for the mismatch), which shrinks the real file while preserving the trigger. (In progress.)

[kiritigowda]

Correction: root cause is GCC 13 at -O3, not amdclang

After fuller isolation, the compiler in the original report was misidentified. The OpenVX CTS is configured by CMake with the default system C compiler /usr/bin/cc (GCC 13.3.0 on Ubuntu 24.04), not amdclang — the workflow only uses amdclang when -DCMAKE_C_COMPILER is explicitly set, which a plain cmake .. of the CTS does not do.

Isolation (same object set, same libopenvx, only test_array.c's compiler flag changed)

Using /usr/bin/cc = cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0, all other harness objects frozen from the -O3 build, linking the identical test_array.c object built two ways:

test_array.c compiled with	Array.vxCreateArray
gcc-13 -O2	20 passed
gcc-13 -O3	5 FAILED (CHAR/INT8/UINT8/INT16/UINT16)

So the trigger is test_array.c compiled by GCC 13 at -O3. -O2/-O1/-O0 are clean. libopenvx optimization level and flags are irrelevant (the object set was held constant). This is a host-compiler miscompile of the CTS harness, independent of the MIVisionX library and independent of GPU/backend.

Minimal reproducer

# Given a built libopenvx + the other CTS objects, compile ONLY test_array.c with gcc:
cc -std=c99 -O3 -DNDEBUG <cts includes> -fPIC -c test_conformance/test_array.c -o test_array.c.o
# link with the rest of the harness -> Array.vxCreateArray/{CHAR,INT8,UINT8,INT16,UINT16} FAIL
# Recompile the SAME file at -O2 -> all 20 pass.

Practical fix

The existing CTS -O2 pin (OpenVX-cts/cmake/openvx.cmake -O3 -> -O2 replace, and the explicit -O2 in .github/workflows/conformance-hip.yml) is the correct mitigation and applies regardless of host compiler.

Note on a standalone reduction

Extracting own_alloc_init_data_items / own_verify_data_items into a fresh TU does not reproduce — it needs the full test_array.c translation unit, so a minimal single-function .c for a GCC bug report requires cvise/creduce driven by the link+run check (in progress).

Environment: Ubuntu 24.04, GCC 13.3.0, MIVisionX develop @ b880c79, OpenVX-cts openvx_1.3.2. Also reproduced in CI (PR-1746).

[kiritigowda]

Simple reproducer + trigger isolated to GCC 13 loop-unswitching

Reproduced on Ubuntu 24.04 / WSL2 with gcc-13 (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0 and built a compact, self-contained reproducer that needs no libopenvx and no CTS harness — just the in-repo OpenVX headers (amd_openvx/openvx/include).

The reproducer

It lifts own_alloc_init_data_items() / own_verify_data_items() verbatim from test_array.c and replaces the vxAddArrayItems + vxMapArrayRange round-trip with a plain memcpy into a stride-packed buffer. The two buffers compared by own_verify_data_items() are therefore byte-identical, so any reported mismatch is a pure host-compiler codegen defect.

I=/path/to/mivisionx/amd_openvx/openvx/include
gcc-13 -std=c99 -O2 -DNDEBUG -I"$I" repro_1748.c -o r_O2 && ./r_O2   # 0 failures
gcc-13 -std=c99 -O3 -DNDEBUG -I"$I" repro_1748.c -o r_O3 && ./r_O3   # 5 failures

-O3 fails exactly the 5 one/two-byte types (CHAR/INT8/UINT8/INT16/UINT16); every >= 4-byte type passes — matching the CTS Array.vxCreateArray failures.

Differential result — GCC only, amdclang is clean

Same source through both host compilers:

compiler	-O0	-O1	-O2	-O3
gcc-13 (13.3.0)	pass	pass	pass	5 FAIL
amdclang (ROCm 23.0.0git)	pass	pass	pass	pass

amdclang stays clean even under -Ofast, -march=native, -funroll-loops, -fvectorize -fslp-vectorize, -flto, and in the full CTS TU. This independently corroborates the corrected root cause: the original amdclang attribution came from the CTS being configured with the default system cc (= GCC 13 on Ubuntu 24.04), not amdclang.

Trigger pinned to loop-unswitching (not the vectorizer)

Bisecting the -O3-only passes:

build	result
gcc-13 -O2	0 failures
gcc-13 -O3	5 failures
gcc-13 -O2 -funswitch-loops	5 failures (trigger reproduced under -O2)
gcc-13 -O3 -fno-unswitch-loops	0 failures (workaround)

-O3 -fno-tree-vectorize / -fno-tree-slp-vectorize still fail, so the vectorizers are not the cause — it's GCC 13's loop-unswitching pass.

Notes

• A single-function extraction with generic typedefs does not reproduce, but keeping the real OpenVX type/enum definitions does — so a compact reproducer needs only the OpenVX headers; no cvise/creduce run is required.
• The existing CTS -O2 pin remains the correct mitigation; -fno-unswitch-loops on the CTS build is a targeted alternative.

Environment: Ubuntu 24.04 (WSL2), gcc-13 13.3.0, amdclang ROCm 23.0.0git, MIVisionX develop, OpenVX-cts openvx_1.3.2.

[kiritigowda]

Reproducer source: repro_1748.c

Self-contained; needs only the in-repo OpenVX headers (amd_openvx/openvx/include) — no libopenvx, no CTS harness.

I=/path/to/mivisionx/amd_openvx/openvx/include
gcc-13 -std=c99 -O2 -DNDEBUG -I"$I" repro_1748.c -o r_O2 && ./r_O2   # 0 failures
gcc-13 -std=c99 -O3 -DNDEBUG -I"$I" repro_1748.c -o r_O3 && ./r_O3   # 5 failures (CHAR/INT8/UINT8/INT16/UINT16)
# amdclang stays clean at every level (control)

repro_1748.c (click to expand)

/*
 * Minimal self-contained reproducer for ROCm/MIVisionX issue #1748.
 *
 * GCC 13 at -O3 miscompiles the OpenVX CTS test_array.c logic so that the
 * post-round-trip data check (own_verify_data_items) spuriously reports a
 * mismatch for the 1- and 2-byte item types (CHAR/INT8/UINT8/INT16/UINT16),
 * while all >= 4-byte types are fine.
 *
 * This file lifts own_alloc_init_data_items() and own_verify_data_items()
 * verbatim from OpenVX-cts/test_conformance/test_array.c and replaces the
 * OpenVX array round-trip (vxAddArrayItems + vxMapArrayRange) with a plain
 * memcpy into a stride-packed buffer -- which is exactly what a conformant
 * implementation does. libopenvx is therefore NOT involved: any mismatch is a
 * pure host-compiler defect in this translation unit.
 *
 *   gcc-13 -std=c99 -O2 -DNDEBUG repro_1748.c -o r_O2 && ./r_O2   -> all pass
 *   gcc-13 -std=c99 -O3 -DNDEBUG repro_1748.c -o r_O3 && ./r_O3   -> small types FAIL
 *
 * If the standalone TU does NOT reproduce on your toolchain, build against the
 * full CTS instead (see gcc_repro.sh); the miscompile is IR-shape sensitive.
 */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <VX/vx.h>

#define FLOAT_EPSILON 0.000001f

typedef struct _own_struct
{
    vx_uint32  some_uint;
    vx_float64 some_double;
} own_struct;

/* ---- lifted verbatim from test_array.c ---- */
static
void* own_alloc_init_data_items(vx_enum item_type, vx_size num_items)
{
    vx_size i;
    vx_size item_size;
    void* p = 0;

    switch (item_type)
    {
    case VX_TYPE_CHAR:              item_size = sizeof(vx_char); break;
    case VX_TYPE_INT8:              item_size = sizeof(vx_int8); break;
    case VX_TYPE_UINT8:             item_size = sizeof(vx_uint8); break;
    case VX_TYPE_INT16:             item_size = sizeof(vx_int16); break;
    case VX_TYPE_UINT16:            item_size = sizeof(vx_uint16); break;
    case VX_TYPE_INT32:             item_size = sizeof(vx_int32); break;
    case VX_TYPE_UINT32:            item_size = sizeof(vx_uint32); break;
    case VX_TYPE_INT64:             item_size = sizeof(vx_int64); break;
    case VX_TYPE_UINT64:            item_size = sizeof(vx_uint64); break;
    case VX_TYPE_FLOAT32:           item_size = sizeof(vx_float32); break;
    case VX_TYPE_FLOAT64:           item_size = sizeof(vx_float64); break;
    case VX_TYPE_ENUM:              item_size = sizeof(vx_enum); break;
    case VX_TYPE_SIZE:              item_size = sizeof(vx_size); break;
    case VX_TYPE_DF_IMAGE:          item_size = sizeof(vx_df_image); break;
    case VX_TYPE_BOOL:              item_size = sizeof(vx_bool); break;
    case VX_TYPE_RECTANGLE:         item_size = sizeof(vx_rectangle_t); break;
    case VX_TYPE_KEYPOINT:          item_size = sizeof(vx_keypoint_t); break;
    case VX_TYPE_COORDINATES2D:     item_size = sizeof(vx_coordinates2d_t); break;
    case VX_TYPE_COORDINATES3D:     item_size = sizeof(vx_coordinates3d_t); break;

    default:
        if (item_type >= VX_TYPE_USER_STRUCT_START && item_type <= VX_TYPE_USER_STRUCT_END)
            item_size = sizeof(own_struct);
        else
            item_size = 0;
        break;
    }

    p = (void *) malloc(num_items * item_size);
    if (NULL == p)
        return p;

    for (i = 0; i < num_items; i++)
    {
        switch (item_type)
        {
        case VX_TYPE_CHAR:
            ((vx_char*)p)[i] = ((i & 1) ? (vx_char)i : -(vx_char)i);
            break;

        case VX_TYPE_INT8:
            ((vx_int8*)p)[i] = ((i & 1) ? (vx_int8)i : -(vx_int8)i);
            break;

        case VX_TYPE_UINT8:
            ((vx_uint8*)p)[i] = (vx_uint8)i;
            break;

        case VX_TYPE_INT16:
            ((vx_int16*)p)[i] = ((i & 1) ? (vx_int16)i : -(vx_int16)i);
            break;

        case VX_TYPE_UINT16:
            ((vx_uint16*)p)[i] = (vx_uint16)i;
            break;

        case VX_TYPE_INT32:
            ((vx_int32*)p)[i] = ((i & 1) ? (vx_int32)i : -(vx_int32)i);
            break;

        case VX_TYPE_UINT32:
            ((vx_uint32*)p)[i] = (vx_uint32)i;
            break;

        case VX_TYPE_INT64:
            ((vx_int64*)p)[i] = ((i & 1) ? (vx_int64)i : -(vx_int64)i);
            break;

        case VX_TYPE_UINT64:
            ((vx_uint64*)p)[i] = (vx_uint64)i;
            break;

        case VX_TYPE_FLOAT32:
            ((vx_float32*)p)[i] = (vx_float32)((i & 1) ? -(1.0f / i) : (100.0f * i));
            break;

        case VX_TYPE_FLOAT64:
            ((vx_float64*)p)[i] = (vx_float64)((i & 1) ? -(1.0 / i) : (100.0 * i));
            break;

        case VX_TYPE_ENUM:
            {
                vx_enum data[3];
                data[0] = VX_READ_ONLY;
                data[1] = VX_WRITE_ONLY;
                data[2] = VX_READ_AND_WRITE;
                ((vx_enum*)p)[i] = data[i % (sizeof(data) / sizeof(vx_enum))];
            }
            break;

        case VX_TYPE_SIZE:
            ((vx_size*)p)[i] = (vx_size)i;
            break;

        case VX_TYPE_DF_IMAGE:
            {
                vx_df_image data[] = { VX_DF_IMAGE_VIRT, VX_DF_IMAGE_RGB, VX_DF_IMAGE_RGBX };
                ((vx_df_image*)p)[i] = data[i % (sizeof(data) / sizeof(vx_df_image))];
            }
            break;

        case VX_TYPE_BOOL:
            ((vx_bool*)p)[i] = (vx_bool)(i & 1 ? vx_true_e : vx_false_e);
            break;

        case VX_TYPE_RECTANGLE:
            {
                vx_rectangle_t r = { (vx_uint32)i, (vx_uint32)(num_items - i), (vx_uint32)(i + i), 0 };
                ((vx_rectangle_t*)p)[i] = r;
            }
            break;

        case VX_TYPE_KEYPOINT:
            {
                vx_keypoint_t kp = { (vx_int32)i, (vx_int32)(num_items - i), (1.0f / (i + 1)), (1.0f / (i + 1)), (1.0f / (i + 1)), (vx_int32)i, (1.0f / (i + 1)) };
                ((vx_keypoint_t*)p)[i] = kp;
            }
            break;

        case VX_TYPE_COORDINATES2D:
            {
                vx_coordinates2d_t c2d = { (vx_uint32)i, (vx_uint32)(num_items - i) };
                ((vx_coordinates2d_t*)p)[i] = c2d;
            }
            break;

        case VX_TYPE_COORDINATES3D:
            {
                vx_coordinates3d_t c3d = { (vx_uint32)i, (vx_uint32)(num_items - i), (vx_uint32)(i + i) };
                ((vx_coordinates3d_t*)p)[i] = c3d;
            }
            break;

        default:
            if (item_type >= VX_TYPE_USER_STRUCT_START && item_type <= VX_TYPE_USER_STRUCT_END)
            {
                own_struct ms = { (vx_uint32)i, 1.0 / (i + 1) };
                ((own_struct*)p)[i] = ms;
            }
            else
            {
                free(p);
                p = NULL;
            }
            break;
        }
    }

    return p;
}

static
int own_verify_data_items(void* ptr1, void* ptr2, vx_size stride, vx_enum item_type, vx_size num_items)
{
    vx_size i;
    vx_uint8* curr_ptr1;
    vx_uint8* curr_ptr2;

    for (i = 0; i < num_items; i++)
    {
        curr_ptr1 = (vx_uint8*)ptr1 + i*stride;
        curr_ptr2 = (vx_uint8*)ptr2 + i*stride;

        switch (item_type)
        {
        case VX_TYPE_CHAR:
            if( ((vx_char*)curr_ptr1)[0] != ((vx_char*)curr_ptr2)[0] )
                return 1;
            break;

        case VX_TYPE_INT8:
            if (((vx_int8*)curr_ptr1)[0] != ((vx_int8*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_UINT8:
            if (((vx_uint8*)curr_ptr1)[0] != ((vx_uint8*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_INT16:
            if (((vx_int16*)curr_ptr1)[0] != ((vx_int16*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_UINT16:
            if (((vx_uint16*)curr_ptr1)[0] != ((vx_uint16*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_INT32:
            if (((vx_int32*)curr_ptr1)[0] != ((vx_int32*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_UINT32:
            if (((vx_uint32*)curr_ptr1)[0] != ((vx_uint32*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_INT64:
            if (((vx_int64*)curr_ptr1)[0] != ((vx_int64*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_UINT64:
            if (((vx_uint64*)curr_ptr1)[0] != ((vx_uint64*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_FLOAT32:
            if ( fabs(((vx_float32*)curr_ptr1)[0] - ((vx_float32*)curr_ptr2)[0]) > FLOAT_EPSILON )
                return 1;
            break;

        case VX_TYPE_FLOAT64:
            if (fabs(((vx_float64*)curr_ptr1)[0] - ((vx_float64*)curr_ptr2)[0]) > FLOAT_EPSILON)
                return 1;
            break;

        case VX_TYPE_ENUM:
            if (((vx_enum*)curr_ptr1)[0] != ((vx_enum*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_SIZE:
            if (((vx_size*)curr_ptr1)[0] != ((vx_size*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_DF_IMAGE:
            if (((vx_df_image*)curr_ptr1)[0] != ((vx_df_image*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_BOOL:
            if (((vx_bool*)curr_ptr1)[0] != ((vx_bool*)curr_ptr2)[0])
                return 1;
            break;

        case VX_TYPE_RECTANGLE:
            if ( ((vx_rectangle_t*)curr_ptr1)[0].start_x != ((vx_rectangle_t*)curr_ptr2)[0].start_x ||
                 ((vx_rectangle_t*)curr_ptr1)[0].start_y != ((vx_rectangle_t*)curr_ptr2)[0].start_y ||
                 ((vx_rectangle_t*)curr_ptr1)[0].end_x != ((vx_rectangle_t*)curr_ptr2)[0].end_x ||
                 ((vx_rectangle_t*)curr_ptr1)[0].end_y != ((vx_rectangle_t*)curr_ptr2)[0].end_y)
                return 1;
        break;

        case VX_TYPE_KEYPOINT:
            if ( ((vx_keypoint_t*)curr_ptr1)[0].x != ((vx_keypoint_t*)curr_ptr2)[0].x ||
                 ((vx_keypoint_t*)curr_ptr1)[0].y != ((vx_keypoint_t*)curr_ptr2)[0].y ||
                 fabs( ((vx_keypoint_t*)curr_ptr1)[0].strength - ((vx_keypoint_t*)curr_ptr2)[0].strength ) > FLOAT_EPSILON ||
                 fabs( ((vx_keypoint_t*)curr_ptr1)[0].scale - ((vx_keypoint_t*)curr_ptr2)[0].scale ) > FLOAT_EPSILON ||
                 fabs( ((vx_keypoint_t*)curr_ptr1)[0].orientation - ((vx_keypoint_t*)curr_ptr2)[0].orientation) > FLOAT_EPSILON ||
                 ((vx_keypoint_t*)curr_ptr1)[0].tracking_status != ((vx_keypoint_t*)curr_ptr2)[0].tracking_status ||
                 fabs(((vx_keypoint_t*)curr_ptr1)[0].error - ((vx_keypoint_t*)curr_ptr2)[0].error) > FLOAT_EPSILON)
                return 1;
            break;

        case VX_TYPE_COORDINATES2D:
            if ( ((vx_coordinates2d_t*)curr_ptr1)[0].x != ((vx_coordinates2d_t*)curr_ptr2)[0].x ||
                 ((vx_coordinates2d_t*)curr_ptr1)[0].y != ((vx_coordinates2d_t*)curr_ptr2)[0].y )
                return 1;
            break;

        case VX_TYPE_COORDINATES3D:
            if ( ((vx_coordinates3d_t*)curr_ptr1)[0].x != ((vx_coordinates3d_t*)curr_ptr2)[0].x ||
                 ((vx_coordinates3d_t*)curr_ptr1)[0].y != ((vx_coordinates3d_t*)curr_ptr2)[0].y ||
                 ((vx_coordinates3d_t*)curr_ptr1)[0].z != ((vx_coordinates3d_t*)curr_ptr2)[0].z)
                return 1;
            break;

        default:
            if (item_type >= VX_TYPE_USER_STRUCT_START && item_type <= VX_TYPE_USER_STRUCT_END)
            {
                if ( ((own_struct*)curr_ptr1)[0].some_uint != ((own_struct*)curr_ptr2)[0].some_uint ||
                    fabs(((own_struct*)curr_ptr1)[0].some_double - ((own_struct*)curr_ptr2)[0].some_double) > FLOAT_EPSILON )
                    return 1;
            }
            else
                return 1;
        }
    }

    return 0;
}
/* ---- end verbatim ---- */

static vx_size item_size_of(vx_enum item_type)
{
    switch (item_type)
    {
    case VX_TYPE_CHAR:   return sizeof(vx_char);
    case VX_TYPE_INT8:   return sizeof(vx_int8);
    case VX_TYPE_UINT8:  return sizeof(vx_uint8);
    case VX_TYPE_INT16:  return sizeof(vx_int16);
    case VX_TYPE_UINT16: return sizeof(vx_uint16);
    case VX_TYPE_INT32:  return sizeof(vx_int32);
    case VX_TYPE_UINT32: return sizeof(vx_uint32);
    case VX_TYPE_INT64:  return sizeof(vx_int64);
    case VX_TYPE_UINT64: return sizeof(vx_uint64);
    case VX_TYPE_FLOAT32:return sizeof(vx_float32);
    case VX_TYPE_FLOAT64:return sizeof(vx_float64);
    default:             return 0;
    }
}

struct { vx_enum t; const char* name; } cases[] = {
    { VX_TYPE_CHAR,   "VX_TYPE_CHAR"   },
    { VX_TYPE_INT8,   "VX_TYPE_INT8"   },
    { VX_TYPE_UINT8,  "VX_TYPE_UINT8"  },
    { VX_TYPE_INT16,  "VX_TYPE_INT16"  },
    { VX_TYPE_UINT16, "VX_TYPE_UINT16" },
    { VX_TYPE_INT32,  "VX_TYPE_INT32"  },
    { VX_TYPE_UINT32, "VX_TYPE_UINT32" },
    { VX_TYPE_INT64,  "VX_TYPE_INT64"  },
    { VX_TYPE_UINT64, "VX_TYPE_UINT64" },
    { VX_TYPE_FLOAT32,"VX_TYPE_FLOAT32"},
    { VX_TYPE_FLOAT64,"VX_TYPE_FLOAT64"},
};

int main(void)
{
    const vx_size num_items = 10; /* == ARRAY_NUM_ITEMS in test_array.c */
    int failures = 0;
    size_t n = sizeof(cases) / sizeof(cases[0]);

    for (size_t k = 0; k < n; k++)
    {
        vx_enum item_type = cases[k].t;
        vx_size item_size = item_size_of(item_type);

        void* src = own_alloc_init_data_items(item_type, num_items);
        if (!src) { printf("alloc failed for %s\n", cases[k].name); failures++; continue; }

        /* Emulate vxAddArrayItems + vxMapArrayRange: a stride-packed copy. */
        vx_size stride = item_size;
        void* dst = malloc(num_items * stride);
        memcpy(dst, src, num_items * item_size);

        int res = own_verify_data_items(src, dst, stride, item_type, num_items);
        printf("%-16s : %s\n", cases[k].name, res == 0 ? "pass" : "FAIL (mismatch after identical copy)");
        if (res != 0) failures++;

        free(dst);
        free(src);
    }

    printf("\n%d failure(s)\n", failures);
    return failures ? 1 : 0;
}