diff options
Diffstat (limited to 'contrib/gcc/cp/NEWS')
| -rw-r--r-- | contrib/gcc/cp/NEWS | 226 |
1 files changed, 226 insertions, 0 deletions
diff --git a/contrib/gcc/cp/NEWS b/contrib/gcc/cp/NEWS new file mode 100644 index 0000000..9cb7d5b --- /dev/null +++ b/contrib/gcc/cp/NEWS @@ -0,0 +1,226 @@ +*** Changes in EGCS 1.1: + +* Namespaces are fully supported. The library has not yet been converted + to use namespace std, however, and the old std-faking code is still on by + default. To turn it off, you can use -fhonor-std. + +* Massive template improvements: + + member template classes are supported. + + template friends are supported. + + template template parameters are supported. + + local classes in templates are supported. + + lots of bugs fixed. + +* operator new now throws bad_alloc where appropriate. + +* Exception handling is now thread safe, and supports nested exceptions and + placement delete. Exception handling overhead on x86 is much lower with + GNU as 2.9. + +* protected virtual inheritance is now supported. + +* Loops are optimized better; we now move the test to the end in most + cases, like the C frontend does. + +* For class D derived from B which has a member 'int i', &D::i is now of + type 'int B::*' instead of 'int D::*'. + +* An _experimental_ new ABI for g++ can be turned on with -fnew-abi. The + current features of this are more efficient allocation of base classes + (including the empty base optimization), and more compact mangling of C++ + symbol names (which can be turned on separately with -fsquangle). This + ABI is subject to change without notice, so don't use it for anything + that you don't want to rebuild with every release of the compiler. + + As with all ABI-changing flags, this flag is for experts only, as all + code (including the library code in libgcc and libstdc++) must be + compiled with the same ABI. + +*** Changes in EGCS 1.0: + +* A public review copy of the December 1996 Draft of the ISO/ANSI C++ + standard is now available. See + + http://www.cygnus.com/misc/wp/ + + for more information. + +* g++ now uses a new implementation of templates. The basic idea is that + now templates are minimally parsed when seen and then expanded later. + This allows conformant early name binding and instantiation controls, + since instantiations no longer have to go through the parser. + + What you get: + + + Inlining of template functions works without any extra effort or + modifications. + + Instantiations of class templates and methods defined in the class + body are deferred until they are actually needed (unless + -fexternal-templates is specified). + + Nested types in class templates work. + + Static data member templates work. + + Member function templates are now supported. + + Partial specialization of class templates is now supported. + + Explicit specification of template parameters to function templates + is now supported. + + Things you may need to fix in your code: + + + Syntax errors in templates that are never instantiated will now be + diagnosed. + + Types and class templates used in templates must be declared + first, or the compiler will assume they are not types, and fail. + + Similarly, nested types of template type parameters must be tagged + with the 'typename' keyword, except in base lists. In many cases, + but not all, the compiler will tell you where you need to add + 'typename'. For more information, see + + http://www.cygnus.com/misc/wp/dec96pub/template.html#temp.res + + + Guiding declarations are no longer supported. Function declarations, + including friend declarations, do not refer to template instantiations. + You can restore the old behavior with -fguiding-decls until you fix + your code. + + Other features: + + + Default function arguments in templates will not be evaluated (or + checked for semantic validity) unless they are needed. Default + arguments in class bodies will not be parsed until the class + definition is complete. + + The -ftemplate-depth-NN flag can be used to increase the maximum + recursive template instantiation depth, which defaults to 17. If you + need to use this flag, the compiler will tell you. + + Explicit instantiation of template constructors and destructors is + now supported. For instance: + + template A<int>::A(const A&); + + Still not supported: + + + Member class templates. + + Template friends. + +* Exception handling support has been significantly improved and is on by + default. The compiler supports two mechanisms for walking back up the + call stack; one relies on static information about how registers are + saved, and causes no runtime overhead for code that does not throw + exceptions. The other mechanism uses setjmp and longjmp equivalents, and + can result in quite a bit of runtime overhead. You can determine which + mechanism is the default for your target by compiling a testcase that + uses exceptions and doing an 'nm' on the object file; if it uses __throw, + it's using the first mechanism. If it uses __sjthrow, it's using the + second. + + You can turn EH support off with -fno-exceptions. + +* RTTI support has been rewritten to work properly and is now on by default. + This means code that uses virtual functions will have a modest space + overhead. You can use the -fno-rtti flag to disable RTTI support. + +* On ELF systems, duplicate copies of symbols with 'initialized common' + linkage (such as template instantiations, vtables, and extern inlines) + will now be discarded by the GNU linker, so you don't need to use -frepo. + This support requires GNU ld from binutils 2.8 or later. + +* The overload resolution code has been rewritten to conform to the latest + C++ Working Paper. Built-in operators are now considered as candidates + in operator overload resolution. Function template overloading chooses + the more specialized template, and handles base classes in type deduction + and guiding declarations properly. In this release the old code can + still be selected with -fno-ansi-overloading, although this is not + supported and will be removed in a future release. + +* Standard usage syntax for the std namespace is supported; std is treated + as an alias for global scope. General namespaces are still not supported. + +* New flags: + + + New warning -Wno-pmf-conversion (don't warn about + converting from a bound member function pointer to function + pointer). + + + A flag -Weffc++ has been added for violations of some of the style + guidelines in Scott Meyers' _Effective C++_ books. + + + -Woverloaded-virtual now warns if a virtual function in a base + class is hidden in a derived class, rather than warning about + virtual functions being overloaded (even if all of the inherited + signatures are overridden) as it did before. + + + -Wall no longer implies -W. The new warning flag, -Wsign-compare, + included in -Wall, warns about dangerous comparisons of signed and + unsigned values. Only the flag is new; it was previously part of + -W. + + + The new flag, -fno-weak, disables the use of weak symbols. + +* Synthesized methods are now emitted in any translation units that need + an out-of-line copy. They are no longer affected by #pragma interface + or #pragma implementation. + +* __FUNCTION__ and __PRETTY_FUNCTION__ are now treated as variables by the + parser; previously they were treated as string constants. So code like + `printf (__FUNCTION__ ": foo")' must be rewritten to + `printf ("%s: foo", __FUNCTION__)'. This is necessary for templates. + +* local static variables in extern inline functions will be shared between + translation units. + +* -fvtable-thunks is supported for all targets, and is the default for + Linux with glibc 2.x (also called libc 6.x). + +* bool is now always the same size as another built-in type. Previously, + a 64-bit RISC target using a 32-bit ABI would have 32-bit pointers and a + 64-bit bool. This should only affect Irix 6, which was not supported in + 2.7.2. + +* new (nothrow) is now supported. + +* Synthesized destructors are no longer made virtual just because the class + already has virtual functions, only if they override a virtual destructor + in a base class. The compiler will warn if this affects your code. + +* The g++ driver now only links against libstdc++, not libg++; it is + functionally identical to the c++ driver. + +* (void *)0 is no longer considered a null pointer constant; NULL in + <stddef.h> is now defined as __null, a magic constant of type (void *) + normally, or (size_t) with -ansi. + +* The name of a class is now implicitly declared in its own scope; A::A + refers to A. + +* Local classes are now supported. + +* __attribute__ can now be attached to types as well as declarations. + +* The compiler no longer emits a warning if an ellipsis is used as a + function's argument list. + +* Definition of nested types outside of their containing class is now + supported. For instance: + + struct A { + struct B; + B* bp; + }; + + struct A::B { + int member; + }; + +* On the HPPA, some classes that do not define a copy constructor + will be passed and returned in memory again so that functions + returning those types can be inlined. + +*** The g++ team thanks everyone that contributed to this release, + but especially: + +* Joe Buck <jbuck@synopsys.com>, the maintainer of the g++ FAQ. +* Brendan Kehoe <brendan@cygnus.com>, who coordinates testing of g++. +* Jason Merrill <jason@cygnus.com>, the g++ maintainer. +* Mark Mitchell <mmitchell@usa.net>, who implemented member function + templates and explicit qualification of function templates. +* Mike Stump <mrs@wrs.com>, the previous g++ maintainer, who did most of + the exception handling work. |
