Validate initializer data length and guard element-count computation in contrib Range shape inference

[titaiwangms]

Summary

The com.microsoft Range operator's shape-inference helper read a fixed number of bytes from an initializer's raw_data without first checking the buffer length, and the element-count computation could pass non-finite or out-of-range values to an int64 cast. This change adds the missing validations and aligns the shape-inference and CPU kernel paths.

Changes

• GetFirstElement now checks raw_data length is at least the element size before reading, and reads via std::memcpy into an aligned local.
• CalcRangeDim and the CPU kernel ComputeRange now reject non-finite computed counts, handle non-positive counts before the int64 cast, and reject counts that are not representable as int64 (>= 2^63). Both paths use identical messages and semantics.
• The output dimension for empty/backward ranges is clamped to 0 in shape inference to match the kernel.

Tests

Added contrib Range model-load regression tests in range_test.cc covering:

• truncated raw_data for start, limit, and delta (double, plus float and int64 element types),
• zero delta,
• a finite-but-too-large element count,
• an exact-size success boundary,
• backward-range zero-dimension inference.

Tests assert on Status (safe for no-exception builds) and are guarded by #ifndef DISABLE_CONTRIB_OPS (throwing cases additionally by !defined(ORT_NO_EXCEPTIONS)). 21/21 RangeTest cases pass locally.

Follow-up

int16 inputs are currently supported only via raw_data (there is no get_data<int16_t> specialization for the non-raw-data path); this is left as a separate follow-up.

[Copilot]

Pull request overview

This PR hardens the com.microsoft Range operator’s shape inference and the CPU kernel against malformed initializer raw_data and invalid/overflowing element-count computations, ensuring model load and runtime execution fail cleanly instead of reading out-of-bounds or hitting undefined conversions.

Changes:

• Added raw_data length validation + aligned reads (via memcpy) in contrib Range shape inference.
• Added non-finite and out-of-int64_t-range guards for the computed element count in both shape inference and the CPU kernel; clamped empty/backward ranges to dimension 0.
• Added contrib Range model-load regression tests covering truncated raw_data, zero delta, too-large counts, and backward-range inferred zero-dim.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 2 comments.

File	Description
onnxruntime/core/graph/contrib_ops/range_schema_defs.cc	Adds raw_data length checks/aligned reads and validates/clamps computed output length during shape inference.
onnxruntime/core/providers/cpu/generator/range.cc	Adds runtime validation for computed element counts (finite + representable in int64_t) and clamps empty/backward ranges.
onnxruntime/test/providers/cpu/generator/range_test.cc	Adds model-load regression tests for contrib Range shape inference failure/success boundary cases.

[yuslepukhin]

• The CUDA kernel (range.cc) has the same non-finite UB and additionally uses int (32-bit) for count — truncation risk. The PR only touches the CPU kernel and shape inference.
• The int16_t non-raw-data path (acknowledged as a separate follow-up in the PR).
• The MSVC #pragma warning(disable : 26451) cleanup.

[titaiwangms]

Thanks @yuslepukhin for the thorough review — all three points are now addressed in the latest revision:

1. CUDA Range kernel (non-finite cast + 32-bit count): Fixed. ComputeRange now applies the same guards as the CPU kernel before the cast — an std::isfinite check, non-positive handling before the conversion, and a rejection of counts at or above 2^63 — with error messages identical to the CPU kernel. The whole launch path (element count, kernel index, and block-count arithmetic) is widened from int to int64_t, using a 64-bit grid-stride loop with the grid x-dimension capped at 2^31−1 so large valid counts are produced without truncation or grid-dimension overflow. Verified on a CUDA build (nvcc 12.9, A100): a valid count above INT_MAX (start=0, delta=1, limit=INT_MAX+16 → count 2147483663) now produces the correct output shape 2147483663, whereas before the change it produced shape 0 due to the 32-bit truncation. Two CUDA-EP tests were added covering the non-finite and ≥2^63 guards.

2. int16 non-raw-data path: Fixed. Added the missing get_data<int16_t> shape-inference specialization (INT16 initializer values are packed into int32_data), plus a red→green regression test that exercises the typed-field path.

3. MSVC #pragma warning(disable : 26451): Removed. The count is now computed entirely in double, which eliminates the 32-bit-arithmetic-then-widen pattern that C26451 flagged; the Windows /analyze CI leg will confirm it stays clean.

Appreciate the careful look — the CUDA parity in particular is a good catch.