cxx-abi | C++ ABI Summary | Code Quality library

For your first question "What is this error about?":

GCC libstdc++ and Clang libc++ has no support for "Extending std::make_shared() to support arrays " which introduced in c++20 yet. So these compilers will try to use template< class T, class... Args > shared_ptr make_shared( Args&&... args );, which trying to forward your arguments (in this case, a cell_t = std::size_t) to construct a std::shared_ptr[]. It cannot be done, so they complain about it.

You can check compiler compatibility here: Compiler support for C++20

The issue was mentioned by @AnttiHaapala: By the instructions ask you to set the prefix to /usr/local/i386elfgcc - maybe you've accidentally dropped this out from the binutils config and installed binutils in /usr/bin instead

The solution was uninstalling the binutils and install it again

• sudo apt-get remove binutils

  sudo apt-get remove --auto-remove binutils

  sudo apt install build-essential

Now the binutils version is 2.34, earlier it was 2.24

Returning the address of a local variable and trying to access it after its lifetime is over is undefined behavior, rationalizing what happens under the hood is a fool's errand because there are no standard rules to be followed (appart, of course, from the aforementioned and linked UB rules), it's quite common different compiler versions changing the way a situation like this is dealt with.

The cygwin64 port isn't actively maintained so you need to update the ace/config-win32.h for this. You need to try which defines should be added to that file, when you have done that and it works, contribute your changes upstream at https://github.com/DOCGroup/ACE_TAO

The issues section at https://github.com/DOCGroup/ACE_TAO is a better place for any ACE questions.

I followed advice VladimirF gave me in the comments, and everthing worked out. This site provided all the necessary guidelines. Only a few minor problems had to be dealth with. Before I could create ./configure file, I was prompted to install some missing autotools, which was simply done using apt. Once ./configure file was ready, I passed in the mostly same configuration that apt originally installed MPICH with (see the long list original question), with 'FC = gfortran-10' 'CC = gcc-10' 'CXX = g++-10' replacing 'FC = gfortran' 'CC = gcc' 'CXX = g++'. Several more prompts had to be dealt with (mostly adding something to configuration or installing missing packages, easily done with Synaptic package manager). After doing all the steps, F08 bindings were succesfully built and work properly. Here is my current MPICH configuration :

MPICH requires the Fortran compiler to support the array descriptor of Technical Specification 29113, and this is only supported in recent versions of gfortran (GNU 10 is ok). Intel compilers have been fine for a while fwiw.

Note that Open MPI is not that picky w.r.t. TS 29113 and does not need support for the array descriptor. GNU 7.5 can be used to generate the mpi_f08 module.

Bottom line, you have two options w.r.t. the mpi_f08 Fortran module:

• use a Fortran support that meets MPICH expectation w.r.t. TS 29113 (e.g. GNU 10, or Intel compilers for example)
• move to Open MPI

The problem is this:

It seems that in your specific environment the Enter key you press to confirm you input is interpreted as a raw '\n'. The original meaning of this character, in fact, is line feed, that means "change line without performing a carriage return" ('\r').

In most terminals the enter key sums the effects of \r and \n, and this doesn't happen in your case.

To work it around try inserting manually a '\r' after the input insertion:

By deeper searching, it can be easily found out that the __main (with an additional underscore internally) is the actual entry point for programs.

The same problem is mentioned in the following two answers:

1. https://stackoverflow.com/a/32164910/14320958
2. https://stackoverflow.com/a/45442576/14320958

Both of which claim some form of a connection to the -lgcc option and the libgcc library.

Renaming main to __main works, but is not recommended (the entry point for kernels is apparently by convention kmain as seen in other questions and answers)

The __main function is what a OS calls when starting a program and it usually contains (for example) a call to exit() (passing the return code from main if it's return type is int) and some other underlying system calls (which are probably system specific, more research would need to be done here)

GCC expects you to include a __main function even on standalone compilations, since it's by specification (or that's what I seen people claim) the default entry point for all applications