I am not sure whether its the right forum to ask this question. I am trying to move to clang compiler from GCC, but our software has tons of components independently developed provding different static archive libraries. All these libraries are finally linked into executable. Now rather than compiling every component with clang from scratch, I was thinking to pick one component at time to compile with clang and use GCC compiled static archives for other components to link into executable using clang compiler. Would this always work ?
So my question is whether GCC compiled object/archives involving C/C++ code would always be compatible with clang generated object files and can be mixed together during link step using clang compiler. Would this always work if I can make sure that our libraries are not using any features of C++11 .
Well, if you do this, you should not use C++11, or the new run-time library, libc++.
I don't know if it will always work, because my GCC to Clang conversion process was done one shared library at a time, but if you use C++11 or libc++ before you have everything building with Clang, you're definitely making life harder for yourself.
So you mean to say even if GCC compiled libraries are not using C++11, but migrated components compiled with clang has C++11, when final executable is created linking all these libraries via clang (GCC compiled libraries + clang compiled code having C++11) can lead to troubles ?
You would have the same problem than using both C++ libraries and compiling all modules with GCC.
As long as you don’t expose C++ API between your static libraries, you should be mostly fine, as libc++ uses namespace versioning and libc++ symbols should not conflict with libstdc++ symbols.
In the final linking step, you will have to link you executable on both GCC libstdc++ and libc++, which may be tricky depending your OS and how both libraries are compiled.
The only symbols that could conflict at link time are the C++ runtime symbols, so your 2 c++ libraries must be using the same C++ runtime library (libsupc++ or libc++abi).
This thread seems to have gone in a strange direction - using clang does not imply or require using libc++.
To answer your original question: this is essentially fine/correct modulo bugs and version incompatibilities (the two compilers don’t necessarily line up perfectly with respect to feature, bug, etc implementation at all times)
You can compile parts of your c++ program (including using c++ standard library types on that interface boundary) with clang and parts with gcc (both using the same standard library) and they should link and run correctly together.
(If you’re curious about the nitty gritty of why this works, its related to a thing called the ABI, and specifically the itanium ABI)
I am aware that both clang and gcc align to generic itanium ABI so ideally there shouldn't be any problem in mixing object code compiled with these 2 compilers. Thanks for the clear answer, I guess I can take up this model to migrate to clang..