Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ?

From	Shao Miller <sha0.miller@gmail.com>
Newsgroups	comp.lang.c
Subject	Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ?
Date	2013-01-11 20:46 -0500
Organization	A noiseless patient Spider
Message-ID	<kcqfa7$vb7$1@dont-email.me> (permalink)
References	(3 earlier) <lna9sflmjj.fsf@nuthaus.mib.org> <kcpj52$lv9$1@dont-email.me> <lntxqnjs1a.fsf@nuthaus.mib.org> <kcqar7$asb$1@dont-email.me> <kcqdj4$7ip$1@speranza.aioe.org>

Show all headers | View raw

On 1/11/2013 20:17, glen herrmannsfeldt wrote:
> Shao Miller <sha0.miller@gmail.com> wrote:
>> On 1/11/2013 17:04, Keith Thompson wrote:
>
> (snip)
>>> It's permitted (in all versions of the language) for a object
>>> of an integer type to have any value in the range of that type.
>>> That has nothing at all to do with arrays; there's no association
>>> (that a compiler can detect) between a given integer value and
>>> indices into some array object.
>
> As long as it isn't used to index any actual array, I agree.
>
>> But that's not so.  A compiler can plainly see an integer object being
>> compared with the bounds of an array, as does the code I was
>> criticizing.  For example:
>
>>    for (i = 0; i < sizeof arr / sizeof arr[0]; i += 10)
>
>> If the count of 'arr' is 4, this alone is sufficient cause to tell the
>> programmer to have their head checked, with no pointers in sight.
>
> (And I presume referencing arr[i] inside the loop.)
>

No, that was the point.  There is no 'arr[i]' in the loop and yet the 
compiler (or run-time support, perhaps) can still see that something 
doesn't seem quite right about this.  Why is 'i' being incremented by 10 
and then compared against the length of 'arr'?  Seems fishy.

> Yes the compiler can plainly see that i indexes the array, and
> also that it can never have a value inside the loop that will
> exceed the array bounds.
>
> A compiler that does bounds checking might not check references
> to arr[i] inside the loop, as it is known to be in bounds.
> (Unless i is otherwise changed inside the loop.)
>

Well my point here was that the loop body didn't make a difference.

>>> That is, unless you actually use the integer value as an index into
>>> a particular array.  In that case, exactly the same rules apply as
>>> for pointers, because the indexing operation is defined in terms
>>> of pointer arithmetic.
>
> (snip)
>> This example is a good one, and rings a bell as being along the lines of
>> the bonus diagnostic I mentioned.
>
>> If I recall correctly, the idea is that whether or not one is using an
>> integer index or a pointer itself for iteration is hardly any different
>> to the compiler, so noting that an index goes "out of bounds" is just as
>> easy as noting that a pointer goes out of bounds, so it's pretty
>> straightforward to provide a bonus diagnostic, even though the program
>> might not suffer from undefined behaviour.
>
> No, other way around.
>
> The standard prohibits pointers from pointing more than one past the
> end of an array, not to aid bounds checking but to allow for hardware
> that might have restrictions on pointers. (Well, that it my
> understanding of the reason.)
>

Sorry; wasn't talking about the Standard and its rationale, but about my 
recollection of the rationale for the diagnostic which could be emitted 
as a sanity-check for a conforming program.  And it makes sense, to me, 
as something that can benefit the programmer (or at least, _other_ 
programmers reading the code; heh!).

> Because of that requirement it would certainly be allowed for an
> implementation doing bounds checking to check that a pointer was
> in range. Unless it is actually used to reference, fetch or store,
> actual data, though, I wouldn't do it.
>
> I used to do a lot of programming in 80286 protected mode with OS/2.
>
> Well, all the modes are still there, but nobody uses them.
>
> A segment descriptor describes a region in memory with an origin and
> length, and any access using that descriptor is checked by the hardware.
>
> When a (16 bit) segment selector is loaded into a segment register,
> the appropriate descriptor is loaded into the correspending register.
>
> Now, compilers won't load random date into segment registers, as it
> will fail if the corresponding descriptor doesn't exist or is invalid.
>
> There is, however, no restriction on the offset. That goes into an
> ordinary register and is only checked when actual access is made to
> data.
>
> There is a hardware trap on fetch or store past the end of a segment.
> I did a lot of debugging using that. OS/2 would put up a nice window
> with the register contents at the time of the trap, making it fairly
> easy to find.
>
> However, in huge model it might cause problems. Personally, I avoid
> huge if possible. Huge allows for arrays more than 64K (in 80286
> mode) or more than 4GB (in 32 bit protected mode) by choosing a
> segment selector based on the index. Even so, though, I would be
> surprised to see the compiler actually do it. It can easily do the
> computation in other registers, only loading the segment register
> when actually addressing data.
>
> Well, the big problem with doing this is that there is no cache
> for segment descriptors. Every time you load a 16 bit selector
> the processor has to also load a 64 bit descriptor from memory.
> (Well, hopefully in processor cache, but still.)
>
> With an appropriate in-processor descriptor cache it could have
> been much faster. Enough to delay the need for 64 bit addressing.
>
> --------------
>
> It might be that some of the Burroughs machines from years past had
> pointer registers that checked that they were in bounds.
>
> But there should be no problem with a program indexing an integer
> variable that could be used to access an array, as long as it isn't
> actually used to access the array outside the bounds.
>
> A compiler on a machine that did have that requirement would have
> to be sure not to load such into the appropriate register until
> it had been checked.
>

Right. :)  It's not that there's an actual problem with the operation, 
it's a diagnostic for the senselessness of the code.

-- 
- Shao Miller
--
"Thank you for the kind words; those are the kind of words I like to hear.

Cheerily,"  -- Richard Harter

Thread

[MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-09 07:26 -0800
  Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? James Kuyper <jameskuyper@verizon.net> - 2013-01-09 11:30 -0500
  Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Eric Sosman <esosman@comcast-dot-net.invalid> - 2013-01-09 11:58 -0500
    Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Robert Wessel <robertwessel2@yahoo.com> - 2013-01-09 12:27 -0600
    Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-09 11:22 -0800
  Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-09 14:39 -0500
  Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-10 02:40 -0800
    Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-10 08:31 -0500
      Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-10 08:49 -0500
        Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-10 06:48 -0800
          Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-10 10:33 -0500
      Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-11 08:19 -0800
        Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-11 12:46 -0500
          Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-11 14:04 -0800
            Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2013-01-11 22:42 +0000
              Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2013-01-12 01:44 +0000
            Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-11 19:30 -0500
              Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-11 20:11 -0500
              Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2013-01-12 01:17 +0000
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-11 20:46 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2013-01-12 03:14 +0000
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-12 14:17 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-12 18:02 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-12 15:13 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-13 16:36 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-13 15:39 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-13 19:17 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-13 16:57 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-13 20:50 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-13 19:08 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-14 00:00 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2013-01-14 21:21 +0000
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-14 17:50 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2013-01-14 01:23 +0000
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-13 21:04 -0500
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-13 19:13 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2013-01-14 21:37 +0000
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-11 18:28 -0800
              Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Keith Thompson <kst-u@mib.org> - 2013-01-11 18:40 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-12 04:30 -0500
    Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2013-01-10 14:37 +0000
      Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-10 06:51 -0800
        Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-10 07:41 -0800
          Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2013-01-10 16:55 +0000
          Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? Shao Miller <sha0.miller@gmail.com> - 2013-01-10 17:41 -0500
            Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-11 03:03 -0800
              Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? m.labanowicz@gmail.com - 2013-01-11 04:14 -0800
                Re: [MUDFLAP] Is sizeof(ARRAY[0]) equivalent to sizeof(*ARRAY) ? James Kuyper <jameskuyper@verizon.net> - 2013-01-11 08:32 -0500

csiph-web