comp.lang.ada
 help / color / mirror / Atom feed
* Non-static constant propagation in optimizing Ada compilers
@ 1990-01-05  1:37 Joe Orost
  0 siblings, 0 replies; 2+ messages in thread
From: Joe Orost @ 1990-01-05  1:37 UTC (permalink / raw)


Ada compilers must be able to compute arithmetic expressions exactly.  It
says so in the language definition.  Should an optimizing compiler use this
"infinite precision" arithmetic when it is performing non-static constant
propagation?  What do you think?   For example:

   function example return float is
      f : float := 1.000000000000000000000000001;
      i : integer;
   begin
      i := integer(f);
      return f - float(i);
   end example;

If an optimizing compiler used "infinite precision" arithmetic,
it could replace the program with:

   function example return float is
   begin
      return 0.000000000000000000000000001;
   end example;

The other alternative is for the compiler to use the arithmetic of the
target machine to perform the calculations (possibly requiring emulation
if host /= target).  In this case, the function would return 0.0, which is
the answer you would get from a non-optimizing compiler.

Other similar problems occur when an optimizing compiler register allocates
floating point values, especially on a 68881/68882 where the registers hold
much more precision than single precision memory locations, which again will
cause different results than in a non-optimizing compiler.  I hear that they
are fixing this problem in the 68040.

^ permalink raw reply	[flat|nested] 2+ messages in thread

* Re: Non-static constant propagation in optimizing Ada compilers
@ 1990-01-07  4:20 Michael Hunter
  0 siblings, 0 replies; 2+ messages in thread
From: Michael Hunter @ 1990-01-07  4:20 UTC (permalink / raw)



joe@petsd.UUCP (Joe Orost) writes:
>Ada compilers must be able to compute arithmetic expressions exactly.  It
>says so in the language definition.  Should an optimizing compiler use this
>"infinite precision" arithmetic when it is performing non-static constant
>propagation?  What do you think?   For example:
really!!!!  or just between model numbers within the range of the type?  Can
anybody give LRM section numbers?

                                                Michael

Mike Hunter - Box's and CPU's from HELL: iapx80[012]86, PR1ME 50 Series, 1750a
UUCP: {ames!elroy, <routing site>}!gryphon!pnet02!bagpiper
INET: bagpiper@pnet02.gryphon.com

^ permalink raw reply	[flat|nested] 2+ messages in thread

end of thread, other threads:[~1990-01-07  4:20 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
1990-01-07  4:20 Non-static constant propagation in optimizing Ada compilers Michael Hunter
  -- strict thread matches above, loose matches on Subject: below --
1990-01-05  1:37 Joe Orost

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox