Re: Elaboration order

[l117593@cliffy.lfwc.lockheed.com (Cordes MJ)]

Robert A Duff (bobduff@world.std.com) wrote:
: In article <4ip58c$gqo@cliffy.lfwc.lockheed.com>,
: Cordes MJ <l117593@cliffy.lfwc.lockheed.com> wrote:
: >Thanks for the input, but that doesn't help me quantify the risk. Scanning
: >the machine code for  a complex application (assume over 200 packages), looking
: >for a class of error which neither of us has seen, does not give me any
: >confidence that we would catch the error if it did show up. Some sort
: >of automated verification is a possibility, but I need a better understanding
: >of the risk before I propose a new tool. And getting a grasp on the risk
: >was the intent of my original post.
: >
: >Is there anybody out there who is doing analysis on elaboration order?

: Sorry if I'm being unhelpful,

(and you're not being "unhelpful")

: but:
: Why are you so interested in elaboration order bugs, when there are
: thousands of other bugs an Ada compiler *might* have?  I see no reason
: why this one is more likely, or more harmful, than any other bug.
: (Assuming we're talking about the sort of compiler bug that involves
: incorrect behavior at run time.)

because elaboration order problems are a different class of bug (if one
of these bugs has ever existed). I can test typical code (for design
errors and code generation errors) given any number of main procedures.
It shouldn't matter if I use a special package (call it unclassified)
containing "dummy" data to test the functionality of some procedure.
The linker doesn't even have to instrument the code if I pass my data
into the procedure by parameter.

Errors introduced at link-time are not so well understood. These errors
could include elaboration order bugs or even the incorrect calculation
of the destination of a unit call. Just because I have never seen one
of these problems, doesn't mean that I shouldn't consider it. And that's
why I asked the question.

: People who write safety critical programs really do analyze the machine
: code, and that's extremely expensive.  Presumably, if the compiler used
: a wrong elaboration order, then this analysis would catch it just like
: any other bug (compiler bug *or* programmer bug) -- it would notice, for
: example, a machine instruction loading from a location that has not yet
: been set to any value.

I haven't seen an analysis tool which could catch the type of error which
we are talking about. And human analysis on complex systems is more prone
to error than the linker or compiler. In any event, if you don't see
elaboration order as a risk, then you will not do any analysis of it.

(and now I'm full circle - is elaboration order a risk? :-)

P.s., no one word answeres, please :-)

: - Bob

--
---------------------------------------------------------------------
Michael J Cordes
Phone: (817) 935-3823
Fax:   (817) 935-3800
EMail: CordesMJ@lfwc.lockheed.com
---------------------------------------------------------------------