Hi,
Quite a long time ago I have decided to use GCC as the only compiler
for my C++* applications (mostly heavy-duty high volume data stream
processing). There are many reasons, but the most important are
listed below:
1. A GCC port is available for every platform I am interested in;
2. It is impossible to maintain portability between compilers of
differerent vendors at the language feature level I am used to.
Otherwise I would either need to select the "lowest common
denominator" supported language subset or raise a heavy #ifdef
orgy in my code. None of them is an option.
3. GCC has a lot of extremely useful extensions and ingenious
integration with inline assembly. The compiler's abilities are
very weak if it comes to autovectorization, but it at least
seamlessly allows me to do things right manually -- a vital
feature.
4. I need as much C++0x features as possible. Even the experimental
support in GCC 4.x dramatically improved the quality of my code. It
is also the reason I use gcc-trunk as the development platform.
Having said that, I wonder what else can I win by sticking to
the GNU compiler as closely as possible. There is a lot of
officially documented extensions (computed gotos, attributes,
PMF conversions etc.) I am aware of (and I continuously monitor
the list), but the purpose of this mail is a kind request to
shed some light on the "grey zone". Could you please point me
the "under the hood" features you think may be interesting for
me? I mean (presumming that there are) the extended type info,
class layout description (e.g. in order to implement reflections
and GC), the __cxa* function ZOO, stable compiler-wide assumptions
in the places where the language standard is unclear or anything
like that. A reference to their documentation will be appreciated.
Best regards,
Piotr Wyderski
*) Or, I should say "G++0x"...
