Curiosity about rage checking

["framefritti@gmail.com" <framefritti@gmail.com>]

Dear *,
this morning, while I was shaving myself, a curiosity about array
access checking in Ada came to my mind...

Consider the following piece of code

for I in A..B loop                                         --
<--------------------+
    Put_Line("Assigning entry for I=" & Integer'Image(I));
--                        |
 
--                        |
    X(I) := 0;    --  <== Access checking for this assignement could
be moved  here--+
end loop


As explained in the fancy comment (I hope you are seeing it with a
fixed-size font :-) the check for
index overflow in the access to X could be done _outside_ the for
loop, saving some computational
effort.

My question is: is an Ada compiler allowed to move the check outside
the loop?


Let me raise few objections myself

  1. The saving is not very important
         But it comes for free (it seems to me).  Moreover, the type
of array access used above is (in my
opinion) very common.

  2. Moving the check outside the loop changes the program behaviour
         if, for example, X index ranges from 1 to 5, A=3 and B=6,
with the check inside the loop 3
iterations are done (and 3 lines are printed), while with the check
outside the loop no iteration is
done.  Therefore, the program behaves differently.  However, the
program is buggy anyway, and
maybe we are not so interested in preserving the behaviour of wrong
programs....

 3. It make debugging harder
   This is a good objection since the exception is raised _before_
(and sometimes much before) the
error actually happens.  Maybe one could use usual access checking
during the debug phase, while
keeping "optimized" checking in the production phase.

Thank you 2#10_0000_0000#