Re: Beware: Rep spec on an enumeration type causes code explosion

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Kevin said

<<Many of the Ada frontends that have been glued to backends that were
  originally designed to support the C language have similar problems early
  on (until the backend can be modified to support Ada features more
  efficiently).  For example, I believe that the GNAT compiler had problems
  implementing some overflow checks efficiently on some targets since the
  backend (which hadn't been modified yet for Ada) didn't support easily
  detecting overflow and turning this into an exception.
  So, GNAT suppresses these checks by default and makes you ask for them.>>

Actually I think that mis-diagnoses the situation. The trouble with checks
and exceptions is not the history of the code generators involved, but
rather the fundamental difficulty in dealing with these items efficiently
in a portable manner. One of the goals of both Greenhills and ACT is to
be able to easily port the technology to different architectures. This
is particularly true in the case of GNAT, where implementations for almost
all common architectures are available.

There are certainly some advantages in the OCS approach of concentrating on
a single processor with respect to these particular items. On the other hand,
good advice is always to actually test out compilers under conditions that
are realistic for you when it comes to performance. You will find results
that may well surprise you, and you certainly cannot assume that
concentrating on a single processor means better performance.

In the case of GNAT, we find overflow checks acceptably efficient in practice,
and improving their performance has not been a priority for any of our
customers (almost all of whom suppress checks for the final delivery if
performance is an issue anyway). There is no doubt they could be improved,
for example on the Power architecture, one can use the sticky bit, and
optimize checks over entire traces, using usual trace scheduling techniques,
but it is hard to believe that this would represent a useful expenditure
of effort.

On the other hand, efficient exception handling is definitely significant
for some users, especially for those who follow a style of putting an
exception handler in every subprogram :-) [yes, this is a style we have
seen!] So that we do see as a major priority, and as I mentioned, it is
the current work item in these parts!

Robert Dewar
Ada Core Technology