Gnat's Ada.Float_Text_IO.Put problem

Gnat's Ada.Float_Text_IO.Put problem

[Stefano M.]

Hi, I recently stumbled across this very weird behaviour from gnat's 
Ada.Float_Text_IO.Put, it seems to always return 0.0 regardless the 
actual value of the given parameter.
Have a look at the following test program:

with Ada.Float_Text_IO;

procedure Main is
    Sample_Float : Float := 10.123;
begin
    Put("Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = ");
    Ada.Float_Text_IO.Put(Sample_Float);
end Main;

And here's what I get:

ste@sim:~/prove$ ./main
Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = -0.00000E+00

The gnat's version I'm using is:

ste@sim:~/prove$ gnat
GNAT 3.3.2 Copyright 1996-2002 Free Software Foundation Inc.

The host I'm compiling on is:

ste@sim:~/prove$ uname -a
OSF1 sim V5.1 2650 alpha

(DEC Alpha Server running Tru64 Unix)

Does anybody have a clue on what's going on here?

Stefano

Re: Gnat's Ada.Float_Text_IO.Put problem

[Adrian Knoth]

Stefano M. <stefano.m@nospam.tin.it> wrote:

> with Ada.Float_Text_IO;
>
> procedure Main is
>     Sample_Float : Float := 10.123;
> begin
>     Put("Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = ");
>     Ada.Float_Text_IO.Put(Sample_Float);
> end Main;
>
> And here's what I get:
>
> ste@sim:~/prove$ ./main
> Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = -0.00000E+00

I'm getting 1.01230E+01 with your code above.

> GNAT 3.3.2 Copyright 1996-2002 Free Software Foundation Inc.

Here: GNAT 3.3.3 20040110 (prerelease) (Debian)

> ste@sim:~/prove$ uname -a
> OSF1 sim V5.1 2650 alpha
> (DEC Alpha Server running Tru64 Unix)

x86 Linux.


-- 
mail: adi@thur.de  	http://adi.thur.de	PGP: v2-key via keyserver

Frauen sind wie Handschellen: Immerwieder eingeschnappt

Re: Gnat's Ada.Float_Text_IO.Put problem

[Stefano M.]

Dennis Lee Bieber wrote:

>         Please supply the EXACT code you are having problems with...
> 
>         Did you even try compiling that? Here's my paraphrased copy of YOUR 
> code, AND the compiler output!

You are right, there was a missing line (since I cleaned the program a 
bit before pasting it on the message).
Anyway:

ste@sim:~/prove$ cat main.adb
with Ada.Float_Text_IO;
with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
      Sample_Float : Float := 10.123;
begin
      Put("Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = ");
      Ada.Float_Text_IO.Put(Sample_Float);
end Main;
ste@sim:~/prove$ gnatmake main
gcc -c main.adb
gnatbind -x main.ali
gnatlink main.ali
ste@sim:~/prove$ ./main
Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = -0.00000E+00

As you can see the problem is still there.
I found this thread on one of the ACT mailing lists which shed some 
light on the matter:
http://www.act-europe.fr/mail/chat/2000-07/threads.html#00038
Seems like I'm not the only one experiencing this kind of problem.

> [wulfraed@beastie ada]$ ./fio
> Standard float IO 'put' of 10.123 = 1.01230E+01

Lucky you!

My performance test programs all rely on the float image function to 
display the results... Missing that function, I coded a very na�ve one, 
using the Float'Floor function and Integer casts all around, but I often 
get costraint errors, this problems's gonna drive me crazy.

Stefano

Re: Gnat's Ada.Float_Text_IO.Put problem

[Adrian Knoth]

Stefano M. <stefano.m@nospam.tin.it> wrote:

> My performance test programs all rely on the float image function to 

Have you ever tried something like:

   Ada.Text_IO.Put (Float'Image (myfloat));

or
  Ada.Text_IO.Put (myfloat'Img);


-- 
mail: adi@thur.de  	http://adi.thur.de	PGP: v2-key via keyserver

  Schlecht: Deine Kinder sind schon sexuell aktiv.
  Panik: Miteinander.

Re: Gnat's Ada.Float_Text_IO.Put problem

[Jeff C,]

"Stefano M." <stefano.m@nospam.tin.it> wrote in message
news:bu3h2r$eid$1@fata.cs.interbusiness.it...
> Hi, I recently stumbled across this very weird behaviour from gnat's
> Ada.Float_Text_IO.Put, it seems to always return 0.0 regardless the


stuff deleted

>
> The gnat's version I'm using is:
>
> ste@sim:~/prove$ gnat
> GNAT 3.3.2 Copyright 1996-2002 Free Software Foundation Inc.
>
> The host I'm compiling on is:
>

What is going on is that the version of gnat in the 3.X.X tree is still
experimental and being
merged. Even x86 Linux has had severe problems. Add to that an relatively
obscure target and
you've got a broken compiler.

Either use GNAT 3.15,
 try to get GNAT Pro (assuming they are willing to sell it to you)
or
Give the version in the gcc CVS archives a try since it has a lot more of
the ACT merges in it.

Re: Gnat's Ada.Float_Text_IO.Put problem

[Georg Bauhaus]

Stefano M. <stefano.m@nospam.tin.it> wrote:
: ste@sim:~/prove$ ./main
: Standard 'put' behaviour from Ada.Float_Text_IO: 10,123 = -0.00000E+00
: 
: As you can see the problem is still there.
: I found this thread on one of the ACT mailing lists which shed some 
: light on the matter:
: http://www.act-europe.fr/mail/chat/2000-07/threads.html#00038
: Seems like I'm not the only one experiencing this kind of problem.

Maybe there are two questions to answer:
Is there a way to switch floating point modes of your hardware?
What do you get for the sample_float value in your object code?
The second question can be answered with a simpler program:

sonnenregen:/tmp$ cat main.adb
procedure Main is
    Sample_Float : Float := 10.123;
begin
   null;
end Main;

sonnenregen:/tmp$ gcc -c -gnatp -v main.adb
Reading specs from /opt/GCC/34/lib/gcc/i686-pc-linux-gnu/3.4/specs
...


sonnenregen:/tmp$ objdump --disassemble main.o

main.o:     file format elf32-i386

Disassembly of section .text:

00000000 <_ada_main>:
   0:   55                      push   %ebp
   1:   89 e5                   mov    %esp,%ebp
   3:   83 ec 04                sub    $0x4,%esp
   6:   b8 cf f7 21 41          mov    $0x4121f7cf,%eax         <<----
   b:   89 45 fc                mov    %eax,0xfffffffc(%ebp)
   e:   c9                      leave  
   f:   c3                      ret    

What do you get at <<----? Does it change when you add a few tenths?


-- Georg

Re: Gnat's Ada.Float_Text_IO.Put problem

[Stefano M.]

Adrian Knoth wrote:

> Have you ever tried something like:
> 
>    Ada.Text_IO.Put (Float'Image (myfloat));
> 
> or
>   Ada.Text_IO.Put (myfloat'Img);

That didn't work either.

Stefano

Re: Gnat's Ada.Float_Text_IO.Put problem

[Stefano M.]

Jeff C, wrote:

> Either use GNAT 3.15,
>  try to get GNAT Pro (assuming they are willing to sell it to you)

Oh, they are. But they are also willing to ask me money for it :-)

> or
> Give the version in the gcc CVS archives a try since it has a lot more of
> the ACT merges in it.

Thanks for the advice. I'm going to do that way.

Stefano

Re: Gnat's Ada.Float_Text_IO.Put problem

[Adrian Knoth]

Stefano M. <stefano.m@nospam.tin.it> wrote:

>>    Ada.Text_IO.Put (Float'Image (myfloat));
>> or
>>   Ada.Text_IO.Put (myfloat'Img);
> That didn't work either.

At least it's consistent ;)


-- 
mail: adi@thur.de  	http://adi.thur.de	PGP: v2-key via keyserver

Stiftung Warentest Vibratoren. Testergebnis: alle befriedigend!

Re: Gnat's Ada.Float_Text_IO.Put problem

[Stefano M.]

Georg Bauhaus wrote:

> Disassembly of section .text:
> 
> 00000000 <_ada_main>:
>    0:   55                      push   %ebp
>    1:   89 e5                   mov    %esp,%ebp
>    3:   83 ec 04                sub    $0x4,%esp
>    6:   b8 cf f7 21 41          mov    $0x4121f7cf,%eax         <<----
>    b:   89 45 fc                mov    %eax,0xfffffffc(%ebp)
>    e:   c9                      leave  
>    f:   c3                      ret    
> 
> What do you get at <<----? Does it change when you add a few tenths?

Georg, thank you for your message.
Unfortunately, I didn't manage to find a disassembler on my target host.
Anyway (and I apoligize in advance if I've misunderstood your message), 
I really doubt that my problem is related to a internal 
misrepresentation of floating point numbers (my own Image function do 
work, although for only "small" floats and with a relatively small 
precision). According to what I read on a ACT mailing list, the problem 
arises with the FPU being "switched" from 80 bit to 64 bit precision by 
other software and if you look at the library code for the image 
function you will find something like:

procedure Set_Image_Real
   (V    : Long_Long_Float;
    S    : out String;
    P    : in out Natural;
    Fore : Natural;
    Aft  : Natural;
    Exp  : Natural)
is
    procedure Reset;
    pragma Import (C, Reset, "__gnat_init_float");
    --  We import the floating-point processor reset routine so that we can
    --  be sure the floating-point processor is properly set for conversion
    --  calls (see description of Reset in GNAT.Float_Control 
(g-flocon.ads).
    --  This is notably need on Windows, where calls to the operating system
     --  randomly reset the processor into 64-bit mode.

[...]

    --  Start of processing for Set_Image_Real

    begin
       Reset;
       Scale := 0;

[...]


I guess the problem is in some way caused by that 'Reset' procedure, 
either being not called because I am not compiling on Windows or being 
called no matter how.

Stefano

Re: Gnat's Ada.Float_Text_IO.Put problem

[Stefano M.]

Georg Bauhaus wrote:

> Maybe there are two questions to answer:
> Is there a way to switch floating point modes of your hardware?
> What do you get for the sample_float value in your object code?
> The second question can be answered with a simpler program:
[...]
> sonnenregen:/tmp$ objdump --disassemble main.o
> 
> main.o:     file format elf32-i386
> 
> Disassembly of section .text:
> 
> 00000000 <_ada_main>:
>    0:   55                      push   %ebp
>    1:   89 e5                   mov    %esp,%ebp
>    3:   83 ec 04                sub    $0x4,%esp
>    6:   b8 cf f7 21 41          mov    $0x4121f7cf,%eax         <<----
>    b:   89 45 fc                mov    %eax,0xfffffffc(%ebp)
>    e:   c9                      leave  
>    f:   c3                      ret    
> 
> What do you get at <<----? Does it change when you add a few tenths?

I suddenly recalled there was a -S switch somewhere, here's what I get:

ste@sim:~/prove$ cat main.adb
procedure Main is
     Sample_Float : Float := 10.123;
begin
    null;
end Main;
ste@sim:~/prove$ gcc -c -S -fomit-frame-pointer -gnatp main.adb
ste@sim:~/prove$ cat main.s
      .verstamp 3 11
      .set noreorder
      .set volatile
      .set noat
      .arch ev4
      .file 1 "main.adb"
      .rdata
      .align 2
$LC0:
      .long 1092745167
      .text
      .align 2
      .globl _ada_main
      .ent _ada_main
_ada_main:
      .frame $30,16,$26,0
      ldgp $29,0($27)
$_ada_main..ng:
      lda $30,-16($30)
      .prologue 1
      lda $1,$LC0
      lds $f10,0($1)
      sts $f10,0($30)
      lda $30,16($30)
      ret $31,($26),1
      .end _ada_main

Anything interesting for you?

Stefano

Re: Gnat's Ada.Float_Text_IO.Put problem

[Georg Bauhaus]

Stefano M. <stefano.m@nospam.tin.it> wrote:
: I really doubt that my problem is related to a internal 
: misrepresentation of floating point numbers

So do I but just to make sure I suggested to have a look, sometimes
surprising things happen :-)
Reset imports __gnat_init_float.
init.c shows HAVE_GNAT_INIT_FLOAT and various #if-framed
__gnat_init_float functions/sections. IFAICS, the fall back
__gnat_init_float is just empty...
maybe the system library provides fset* functions that you
can try?



-- Georg

Re: Gnat's Ada.Float_Text_IO.Put problem

[Georg Bauhaus]

Stefano M. <stefano.m@nospam.tin.it> wrote:
: I suddenly recalled there was a -S switch somewhere, here's what I get:

[slightly condensed:]

$LC0:
      .long 1092745167

      ldgp $29,0($27)   stack pointer, 0(kernel register)
      lda $30,-16($30)  saved, -16(saved)
      lda $1,$LC0       load address register $1, $LC0 (there is 1092745167)
      lds $f10,0($1)    $f10 is a floating point register
      sts $f10,0($30)       (indirectly $LC0 if I'm not mistaken)
      lda $30,16($30)   mirrors second line
      ret $31,($26),1    (31: return address, 26: kernel register)


the 1092745167 from $LC0: is 16#4121F7CF#. It is the same as
the number from offset 6: in the x86 example,

  6:   b8 cf f7 21 41          mov    $0x4121f7cf,%eax         <<----

In binary, this number and its negative (tried for checking) read

2#0_10000010_01000011111011111001111#
2#1_10000010_01000011111011111001111#

In IEEE single precision this means
sign: +
sign: -
Exponent: 130 - 127 = 3
Exponent: 130 - 127 = 3
fraction: (1.)01000011111011111001111
fraction: (1.)01000011111011111001111

With a left_shift of 3 (because exponent = 3) the resulting number
is 2#1010.00011111011111001111# = (-)1.01230E+01 = (-)10.123.

If this interpretation is correct then there is indeed
no representation problem. (I'm not really familiar with any
CPU or fpt, so caveat lector.)

-- Georg

Re: Gnat's Ada.Float_Text_IO.Put problem

[tmoran]

>>    Ada.Text_IO.Put (Float'Image (myfloat));
>That didn't work either.
  Depending on the range of your numbers, perhaps you should try using
fixed point, or convert to fixed point for printout.

Re: Gnat's Ada.Float_Text_IO.Put problem

[Duncan Sands]

On Thursday 15 January 2004 19:50, tmoran@acm.org wrote:
> >>    Ada.Text_IO.Put (Float'Image (myfloat));
> >
> >That didn't work either.
>
>   Depending on the range of your numbers, perhaps you should try using
> fixed point, or convert to fixed point for printout.

Wouldn't it be better to recompile the GNAT runtime library with
debugging turned on (-g), and step through it with the debugger
to find out exactly where things are going wrong?

All the best,

Duncan.

Re: Gnat's Ada.Float_Text_IO.Put problem

[tmoran]

> Wouldn't it be better to recompile the GNAT runtime library with
> debugging turned on (-g), and step through it with the debugger
> to find out exactly where things are going wrong?
   I'm in favor of debugging incorrect programs.  But was the OP
interested in debugging Gnat or in running some program, and getting
correct output, of his own?  Also, isn't that version of Gnat already
obsolete and replaced by a less buggy one?  Suggesting that ACT or
somebody knows about and has fixed the bug.
  And stepping through with a debugger is such a tedious method of
debugging it's pretty near a last resort, for me at any rate.

Re: Gnat's Ada.Float_Text_IO.Put problem

[Duncan Sands]

On Friday 16 January 2004 09:48, tmoran@acm.org wrote:
> > Wouldn't it be better to recompile the GNAT runtime library with
> > debugging turned on (-g), and step through it with the debugger
> > to find out exactly where things are going wrong?
>
>    I'm in favor of debugging incorrect programs.  But was the OP
> interested in debugging Gnat or in running some program, and getting
> correct output, of his own?

One way of getting a correctly running program is to fix GNAT yourself.
For the runtime library this often isn't hard.

> Also, isn't that version of Gnat already
> obsolete and replaced by a less buggy one?

I didn't follow the thread, so I don't know which version it was - gcc-3.3?

> Suggesting that ACT or
> somebody knows about and has fixed the bug.
>   And stepping through with a debugger is such a tedious method of
> debugging it's pretty near a last resort, for me at any rate.

It is tedious, but when you are trying to find out where things are going
wrong in a mass of code you are unfamiliar with (like the runtime library),
it can be quite helpful.

All the best,

Duncan.

Re: Gnat's Ada.Float_Text_IO.Put problem

[Jeff C,]

"Duncan Sands" <baldrick@free.fr> wrote in message
news:mailman.10.1074246338.303.comp.lang.ada@ada-france.org...
> On Friday 16 January 2004 09:48, tmoran@acm.org wrote:
> > > Wouldn't it be better to recompile the GNAT runtime library with
> > > debugging turned on (-g), and step through it with the debugger
> > > to find out exactly where things are going wrong?
> >
> >    I'm in favor of debugging incorrect programs.  But was the OP
> > interested in debugging Gnat or in running some program, and getting
> > correct output, of his own?
>
> One way of getting a correctly running program is to fix GNAT yourself.
> For the runtime library this often isn't hard.
>
>

This is somewhat true and that is why it is great to have the compiler but
if the version you are running can't output a simple floating-point valuie
from the simplest of programs...it is time to get a more stable version...

Re: Gnat's Ada.Float_Text_IO.Put problem

[Duncan Sands]

> This is somewhat true and that is why it is great to have the compiler but
> if the version you are running can't output a simple floating-point valuie
> from the simplest of programs...it is time to get a more stable version...

I can't argue with that!

Duncan.