Re: Memory protection between compilation units?

Mateusz Viste <mateusz@not.gonna.tell> writes:

On 14.06.2025 01:31, Tim Rentsch wrote:
>

It isn't wrong to think of bitwise-and as masking-in (or possibly
masking-out) of certain bits, but it still isn't a modulo.  A
modulo operation is what is desired;

>
By "different viewpoints," I meant that while you approach the
problem by applying a modulo operation to the index so it fits the
array size, I tend to think in terms of ensuring the index
correctly maps to a location within an n-bit address space.
Naturally, the array should accommodate the maximum possible index
for the given address space, and that?s where the original code
fell short.  And you're absolutely right that hardcoded values are
problematic, the size of the array should have been linked with
the n-bits address space expectation.

I understand what you're doing.  However one thinks of it, what is
needed is a way to ensure the produced index value is in the range
of array index values, and that the mapping covers the full range of
array index values.  Using bitwise-and is a way of solving a less
general problem.  Unfortunately:  one, although it is known that
using bitwise-and works only for certain array sizes, there was no
check or assertion in the code to verify that requirement;  two,
it's a holdover from earlier times when the performance difference
might matter, but now it's a premature optimization (and in most
cases does not result in any improvement);  and three, in this case
using bitwise-and contributed to the bug, which wouldn't have
happened if modulo had been used instead.