Can Clang Compile Code with Gcc Compiled .A Libs

Can Clang compile code with GCC compiled .a libs?

Yes, you usually can use clang with GCC compiled libraries (and vice versa, use gcc with CLANG compiled libraries), because in fact it is not compilation but linking which is relevant. You might be unlucky and get unpleasant suprises.

You could in principle have some dependencies on the version of libstdc++ used to link the relevant libraries (if they are coded in C++). Actually, that usually does not matter much.

In C++, name mangling might in theory be an issue (there might be some corner cases, even incompatibilities between two different versions of g++). Again, in practice it is usually not an issue.

So usually you can mix CLANG (even different but close versions of it) with GCC but you may have unpleasant surprises. What should be expected from any C++ compiler (be it CLANG or GCC) is just to be able to compile and link an entire software (and all libraries) together using the same compiler and version (and that includes the same C++ standard library implementation). This is why upgrading a compiler in a distribution is a lot of work: the distribution makers have to ensure that all the packages compile well (and they do get surprises!).

Beware that the version of libstdc++ does matter. Both Clang & GCC communities work hard to make its ABI compatible for compiler upgrades, but there are subtle corner cases. Read the documentation of your particular and specific C++ standard library implementation. These corner cases could explain mysterious crashes when using a good C++ library binary (compiled with GCC 5) in your code compiled with GCC 8. The bug is not in the library, but the ABI evolved incompatibly.

gcc vs clang common library issue

g++ and clang++ are compatible as compilers (because they both follow the Itanium ABI), but they may come with incompatible standard library implementations.

g++ comes with a standard library implementation called libstdc++. You can direct g++ to use a different implementation but this is not exactly trivial.

clang++ sometimes comes without a standard library implementation of its own (and is configured to use implementation provided by g++), and sometimes comes with an implementation called libc++. One can easily switch clang++ to use either libc++ or libstdc++ with a single command line option.

So your question boils down to what standard library implementation(s) your applications use. If they use the same implementation, you need to build Boost with that implementation (and either compiler). If they use different implementations, you need two separate builds of Boost.

Mixing components built against different standard library implementations in the same application can sometimes be done, but is not straightforward, entails a lot of restrictions, and with things like boost is either not feasible or downright impossible.

Is there a gcc/clang flag to validate a C++ program without compiling

I think the -fsyntax-only flag may be what you're looking for. Though there could be some errors that would only be caught at later stages of compilation, so there isn't a 100% guarantee that code which passes -fsyntax-only would successfully compile.

Otherwise, it's worth noting that turning off optimization (-O0) by itself usually makes compilation many times faster.

Are llvm-gcc and clang binary compatible with gcc? - particularly mingw gcc on Windows

Yes, for C code Clang and GCC are compatible (they both use the GNU Toolchain for linking, in fact.) You just have to make sure that you tell clang to create compiled objects and not intermediate bitcode objects. C ABI is well-defined, so the only issue is storage format.

C++ is not portable between compilers in the slightest; different compilers use different virtual table calls, constructors, destruction, name mangling, template implementations, etc. As a rule you should assume objects from one C++ compiler will not work with another.

However yes, at the time of writing Clang++ is able to use GCC/C++ compiled libraries as well; I recently set up a rig to compile C++ programs with clang using G++'s standard runtime library and it compiles+links just fine.

Problem compiling c++ project using Boost with Clang

Are you giving clang the -pedantic option? It looks like -pedantic is triggering the error. You can always just remove that option.

Can't compile and link with dynamic library

clang hello.c -o hello -Igreeting

attempts to compile and link, but you didn't supply the name of the library to link with:

clang hello.c -o hello -Igreeting greeting.so #<= greeting.so added

Then you should be able to run the output with:

LD_LIBRARY_PATH=. ./hello 

The idea is that the lib will be put in one of your systems library paths and because you haven't done that, the LD_LIBRARY_PATH environment variable is a kind of a hack to make it work without it.

With gcc/clang on Linux, you can also hardcode the full path:

clang hello.c -o hello -Igreeting $PWD/greeting.so

or you can make the dynamic linker search for the dependency relative to the location of the executable

clang hello.c -o hello -Igreeting '-Wl,-rpath=$ORIGIN' greeting.so

With either of the two methods above, you don't need the LD_LIBRARY_PATH=. part anymore.

There's a lot more to dynamic libraries, and I recommend you study up more on them e.g., from Ulrich Drepper's DSO Howto writeup.

---

Related Topics