1. Forum
  2. Newsgroups
  3. comp.lang.c

  • Re: Memory protection between compilation units?

    From Tim Rentsch@[email protected] to comp.lang.c on Tue Jul 1 09:54:36 2025
    From Newsgroup: comp.lang.c

    Mateusz Viste <[email protected]> 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.
    --- Synchronet 3.21a-Linux NewsLink 1.2