Re: eliminating array bounds checking overhead

> It is possible to direct the compiler to avoid a second branch
> instruction by rewriting the test as follows:
>
> if ((unsigned)(i - (lo+1)) < hi)
>
> Of course, if "lo" is not a constant, the savings is likely to be very
> marginal (in-line flow for an addition and subtraction vs a comparison
> and a conditional branch which usually flows in-line). It is probably
> not reasonable to expect a compiler to always make this transformation
> during optimization. However, the generated output for an "array
> bounds checking" operation probably should produce the equivalent
> code, espically when "lo" and "hi" are known constants.
> [It's still pretty fast if you can put lo+1 ad hi in registers. -John]


If hi & lo are constants, then it is a very reasonable transformation
to expect the compiler to perform (on architectures where it is
beneficial). If not, then it is unlikely to be able to. Its not a
performance issue, its a correctness one: the two forms are only
equivalent when hi > lo.


Of course an intelligent optimizing compiler could look at the names of
the variables and deduce that that was indeed the case :-)
-------------
Mark Williams

Return to the comp.compilers page.
Search the comp.compilers archives again.