Re: RISC

[Robert A Duff <bobduff@world.std.com>]

Tucker Taft <stt@averstar.com> writes:

> This is my cue to pipe up with the Compiler Writer's Lament.
> Rep clauses are difficult to support because every special case
> makes a compiler more complicated and more buggy, and makes
> optimization harder.  So compilers really "want" to do everything
> one way if possible, and then optimize the heck out of that.

Ada 83 said that compilers don't have to support rep clauses that can't
be "handled simply by the underlying hardware".  It's not entirely clear
what that means.

Ada 95 has a whole lot of verbiage that amounts to more or less the same
thing: the compiler has to support some minimal capabilities that we
thought were "simple" or "reasonably efficient" on all machines.

If I were designing a language from scratch, I think I would require
much more, including bit fields oddly aligned, and crossing word
boundaries and so forth.

I don't think the "underlying hardware" is really the issue, especially
in this networked era, the piece of hardware you're trying to mimic
might be a different computer, or some weird peripheral device.

Tucker's right: these things are hard to implement efficiently.  But I
think it's worth it.  I really think the usefulness of Ada's rep clauses
is seriously damaged by their lack of portability.  If I ran the circus,
all compilers would support exactly the same record layouts.

There are also a lot of things that rep clauses just can't express.  Eg,
TCP/IP protocols often have data structures defined like "a count byte,
followed by an array of sub-records" where the count gives the number of
sub-records, or the number of bytes including (or not including) the
count byte itself.  I would like to have a language that could describe
that sort of thing at a reasonably high level.

- Bob