Hi all,

I'm not a Fortran coder but I need to call the sub-routine ADAPT.f from a c code.

This subroutine calculates a multiple integral of a given function.

My problem is that the c code works with no problem in a 32 bit machine but it does not in a 64 bit machine, and the problem seems to be related to adapt, which calculations gives a NA rather than the result of integration.

Since fortran is quite obscure for me, I don't know why is this happening. Maybe I should change some data type (from real to double), but I'm not sure. Does anyone have a clue?

Thanks in advance

I assume you mean you recompiled both the C code and the fortran code for 64 bit mode to run on the 64 bit machine.

Depending on your real objective, you might have been better off keeping the 32 bit binary that worked on a 32 bit machine and using that on the 64 bit machine. You might need some extra library installed first, but in general it is easy to use 32 bit executables on a 64 bit Linux.

You could even recompile a 32 bit executable on a 64 bit Linux (again maybe needing some extra packages installed first).

But if you have good reason to want the executable to be 64 bit, that also ought to be possible.

There is an outside chance you are running into some calling convention issue, such that the passing of data between the C code and the Fortan is compiled correctly for 32 bit mode, but not for 64 bit mode. I don't think so, but I can't rule it out.

Other than that, I can only think of one theory that fits the symptoms and I can't follow the Fortran code well enough to estimate whether that theory fits:

In x86 32 bit architecture, the optimizer can use 80 bit floating point for intermediate values even when the code specifies float (32 bit floating point) or double (64 bit floating point). The code may accidentally depend on the extra precision. I can't follow the code, but it may compute some small difference that rounds to zero in 32 bit but nonzero in 80 bit, then use that as a divisor destroying the rest of the computation.

In x86-64 architecture, float or double each use exactly the nominal number of bits (32 or 64) never 80. So you don't get the extra precision that code might need.

The comments in that code suggest a change from real to double. It has a good chance to help. Why didn't you try before even asking? I'm not sure either.

Thanks for your response. I tried your suggestions but for several reasons I failed to make it work.

I tried this but I got an error message "wrong ELF class: ELFCLASS32". As far as I can see this shows that I'm pointing to a 32 bit shared object.


I'm trying to change it but unfortunately the code calls other subroutines, so all the codes should be harmonized. That was an hypothesis but it could be a completely false one. I will try to work in this direction. Thanks for the help

Was that a link time error? Building the 32 bit binaries on a 64 bit system should be possible, but not as easy as taking 32 bit binaries already built from a 32 bit system.

I hope you didn't misunderstand what I said could be mixed. You can run an entirely 32 bit task image on a 64 bit system. That means the main program is a 32 bit binary as is every .so it uses. You cannot mix 32 and 64 in one image. To use a 32 bit .so you need the main program to be 32 bit.