|WARNING| net/bnxt: fix bit allocator out of bounds read

[dpdklab at iol.unh.edu]

Test-Label: ai-code-review
Test-Status: WARNING
https://dpdk.org/patch/170611

_AI Code Review_

=== Patch Review: series.patch (via Claude) ===
Review date: 2026-10-05

# DPDK Patch Review

## Patch Summary
This patch fixes an out-of-bounds read in the bnxt driver's bit allocator. The original do-while loop could access `blist->bdata[idx]` when `idx == bsize_64`, which is one element past the array end.

---

## ERRORS

None.

---

## WARNINGS

### 1. Missing error check on return value
**File:** `drivers/net/bnxt/tf_ulp/ulp_gen_hash.c`  
**Location:** Line with `jdx = rte_clz64(~bentry)`

The `rte_clz64()` function assumes `~bentry` is non-zero. If `bentry == -1UL`, then `~bentry == 0`, and `rte_clz64(0)` behavior is undefined (returns the operand width, which would be 64).

However, the outer condition `if (bentry != -1UL)` already guards against this, so the code is correct. No issue here.

---

## INFO

### 1. Loop refactoring is correct
The patch correctly converts the do-while loop to a while loop that checks bounds before accessing the array:

**Before:**
```c
do {
    bentry = blist->bdata[idx++];  /* reads [bsize_64] when idx starts at bsize_64 */
} while (bentry == -1UL && idx <= bsize_64);
```

**After:**
```c
while (idx < bsize_64) {
    bentry = blist->bdata[idx];  /* reads [0..bsize_64-1] only */
    if (bentry != -1UL) {
        /* allocate bit */
    }
    idx++;
}
```

This eliminates the out-of-bounds read and makes the intent clearer.

### 2. Index arithmetic correctly adjusted
The original code used `(idx - 1)` to compensate for the post-increment in the loop condition. The refactored code correctly uses `idx` directly since the increment now happens at the end of the loop body.

### 3. .mailmap update is appropriate
Adding the new contributor to `.mailmap` is correct process.

---

## SUMMARY

**This patch is correct and ready to merge.**

The fix properly addresses the out-of-bounds read by checking the array bounds before indexing. The loop refactoring is straightforward and maintains the original logic while eliminating the buffer overrun. No style violations or other issues were found.