gcc-multilib is useful for cross-compiling, that is, compiling a program to run on a different processor architecture. For example, you would need gcc-multilib if you are running on 64-bit Ubuntu and want to compile a program to run on 32-bit Ubuntu (or on ARM etc. you get the idea).

They’re different approaches to the same general problem, with somewhat different scopes: running binaries built for different architectures.

When you’re given a binary to run, you need three things: the libraries it needs (if any, including its dynamic loader), support for the system calls it makes, and the ability to interpret the machine instructions it contains. Multilib and multiarch address the first.

Multilib works with a table of known variants, per architecture. This originally addressed ABI variants, e.g. on MIPS, but its most common use nowadays is 32-bit support on x86: it typically defines lib32 as the 32-bit library directory (and this definition is x86-specific). So a multilib setup might provide the 64-bit loader in /lib and the 32-bit one in /lib32. On the compiler side, you specify -m32 to build a 32-bit binary using multilib.

Multiarch is more general: its definitions don’t depend on the host architecture. All libraries are found in a lib subdirectory corresponding to their target architecture; /usr/lib/x86_64-linux-gnu/, /usr/lib/i386-linux-gnu, etc. On the compiler side, you use the appropriate cross-compiler.

Which approach you use to run a 32-bit binary depends on the distribution. Debian and its derivatives now use multiarch, other distributions use multilib.

Multilib means support for multiple architectures, so you can compile binaries for them.

Given the bug you show, you should be safe as long you build binaries for AMD64 architecture (64-bit) and IA32, as that is what your machine is.

Otherwise, better to choose without multilib.

TL-DR; There is no need. Use a wrapper and link to the desired standard libraries.

For soft and hard float, both the gcc libraries and generated code are effected. For a system with armv4 and armv5, the same compiler will always be able to generate the same code. Moreover, the generated objects are the same ABI. Ie, they pass parameters using the same mechanism. So the assembler instruction with-in an object may target armv4 or armv5. If you are on the armv5 architecture you may even link and run the armv4 objects. There is no issue except the code is sub-optimal.

You may build gcc libraries twice with the armv4 and armv5 options. Save the generated libraries. Headers will be identical. When you build armv5, use the armv5 libraries. Use -mcpu, -isystem (if you like) and -L to get the armv5 optimized libraries. For this reason I would use the armv4 build as the default. For certain this can be done with -freestanding and a gcc-armv5 wrapper script.

The multilib configuration is special in that the actual compiler binary can generate two sets of prologue and epilogue. Even before multilib it was always possible to generate either armv4 or armv5 code using the same compiler with -mcpu, or -march and -mtune. It is just they had the same prologue and epilogue. The instruction generation backend in gcc has always been multicpu. Probably multilib would better be named multiabi.