NEWS revision 117395
1*** Changes in GCC 3.3: 2 3* The "new X = 3" extension has been removed; you must now use "new X(3)". 4 5* G++ no longer allows in-class initializations of static data members 6 that do not have arithmetic or enumeration type. For example: 7 8 struct S { 9 static const char* const p = "abc"; 10 }; 11 12 is no longer accepted. 13 14 Use the standards-conformant form: 15 16 struct S { 17 static const char* const p; 18 }; 19 20 const char* const S::p = "abc"; 21 22 instead. 23 24 (ISO C++ is even stricter; it does not allow in-class 25 initializations of floating-point types.) 26 27*** Changes in GCC 3.1: 28 29* -fhonor-std and -fno-honor-std have been removed. -fno-honor-std was 30 a workaround to allow std compliant code to work with the non-std 31 compliant libstdc++-v2. libstdc++-v3 is std compliant. 32 33* The C++ ABI has been fixed so that `void (A::*)() const' is mangled as 34 "M1AKFvvE", rather than "MK1AFvvE" as before. This change only affects 35 pointer to cv-qualified member function types. 36 37* The C++ ABI has been changed to correctly handle this code: 38 39 struct A { 40 void operator delete[] (void *, size_t); 41 }; 42 43 struct B : public A { 44 }; 45 46 new B[10]; 47 48 The amount of storage allocated for the array will be greater than 49 it was in 3.0, in order to store the number of elements in the 50 array, so that the correct size can be passed to `operator delete[]' 51 when the array is deleted. Previously, the value passed to 52 `operator delete[]' was unpredictable. 53 54 This change will only affect code that declares a two-argument 55 `operator delete[]' with a second parameter of type `size_t' 56 in a base class, and does not override that definition in a 57 derived class. 58 59* The C++ ABI has been changed so that: 60 61 struct A { 62 void operator delete[] (void *, size_t); 63 void operator delete[] (void *); 64 }; 65 66 does not cause unnecessary storage to be allocated when an array of 67 `A' objects is allocated. 68 69 This change will only affect code that declares both of these 70 forms of `operator delete[]', and declared the two-argument form 71 before the one-argument form. 72 73* The C++ ABI has been changed so that when a parameter is passed by value, 74 any cleanup for that parameter is performed in the caller, as specified 75 by the ia64 C++ ABI, rather than the called function as before. As a 76 result, classes with a non-trivial destructor but a trivial copy 77 constructor will be passed and returned by invisible reference, rather 78 than by bitwise copy as before. 79 80* G++ now supports the "named return value optimization": for code like 81 82 A f () { 83 A a; 84 ... 85 return a; 86 } 87 88 G++ will allocate 'a' in the return value slot, so that the return 89 becomes a no-op. For this to work, all return statements in the function 90 must return the same variable. 91 92*** Changes in GCC 3.0: 93 94* Support for guiding declarations has been removed. 95 96* G++ now supports importing member functions from base classes with a 97 using-declaration. 98 99* G++ now enforces access control for nested types. 100 101* In some obscure cases, functions with the same type could have the 102 same mangled name. This bug caused compiler crashes, link-time clashes, 103 and debugger crashes. Fixing this bug required breaking ABI 104 compatibility for the functions involved. The functions in questions 105 are those whose types involve non-type template arguments whose 106 mangled representations require more than one digit. 107 108* Support for assignment to `this' has been removed. This idiom 109 was used in the very early days of C++, before users were allowed 110 to overload `operator new'; it is no longer allowed by the C++ 111 standard. 112 113* Support for signatures, a G++ extension, have been removed. 114 115* Certain invalid conversions that were previously accepted will now 116 be rejected. For example, assigning function pointers of one type 117 to function pointers of another type now requires a cast, whereas 118 previously g++ would sometimes accept the code even without the 119 cast. 120 121* G++ previously allowed `sizeof (X::Y)' where Y was a non-static 122 member of X, even if the `sizeof' expression occurred outside 123 of a non-static member function of X (or one of its derived classes, 124 or a member-initializer for X or one of its derived classes.) This 125 extension has been removed. 126 127* G++ no longer allows you to overload the conditional operator (i.e., 128 the `?:' operator.) 129 130* The "named return value" extension: 131 132 int f () return r { r = 3; } 133 134 has been deprecated, and will be removed in a future version of G++. 135 136*** Changes in GCC 2.95: 137 138* Messages about non-conformant code that we can still handle ("pedwarns") 139 are now errors by default, rather than warnings. This can be reverted 140 with -fpermissive, and is overridden by -pedantic or -pedantic-errors. 141 142* String constants are now of type `const char[n]', rather than `char[n]'. 143 This can be reverted with -fno-const-strings. 144 145* References to functions are now supported. 146 147* Lookup of class members during class definition now works in all cases. 148 149* In overload resolution, type conversion operators are now properly 150 treated as always coming from the most derived class. 151 152* C9x-style restricted pointers are supported, using the `__restrict' 153 keyword. 154 155* You can now use -fno-implicit-inline-templates to suppress writing out 156 implicit instantiations of inline templates. Normally we do write them 157 out, even with -fno-implicit-templates, so that optimization doesn't 158 affect which instantiations are needed. 159 160* -fstrict-prototype now also suppresses implicit declarations. 161 162* Many obsolete options have been removed: -fall-virtual, -fmemoize-lookups, 163 -fsave-memoized, +e?, -fenum-int-equivalence, -fno-nonnull-objects. 164 165* Unused virtual functions can be discarded on some targets by specifying 166 -ffunction-sections -fvtable-gc to the compiler and --gc-sections to the 167 linker. Unfortunately, this only works on Linux if you're linking 168 statically. 169 170* Lots of bugs stomped. 171 172*** Changes in EGCS 1.1: 173 174* Namespaces are fully supported. The library has not yet been converted 175 to use namespace std, however, and the old std-faking code is still on by 176 default. To turn it off, you can use -fhonor-std. 177 178* Massive template improvements: 179 + member template classes are supported. 180 + template friends are supported. 181 + template template parameters are supported. 182 + local classes in templates are supported. 183 + lots of bugs fixed. 184 185* operator new now throws bad_alloc where appropriate. 186 187* Exception handling is now thread safe, and supports nested exceptions and 188 placement delete. Exception handling overhead on x86 is much lower with 189 GNU as 2.9. 190 191* protected virtual inheritance is now supported. 192 193* Loops are optimized better; we now move the test to the end in most 194 cases, like the C frontend does. 195 196* For class D derived from B which has a member 'int i', &D::i is now of 197 type 'int B::*' instead of 'int D::*'. 198 199* An _experimental_ new ABI for g++ can be turned on with -fnew-abi. The 200 current features of this are more efficient allocation of base classes 201 (including the empty base optimization), and more compact mangling of C++ 202 symbol names (which can be turned on separately with -fsquangle). This 203 ABI is subject to change without notice, so don't use it for anything 204 that you don't want to rebuild with every release of the compiler. 205 206 As with all ABI-changing flags, this flag is for experts only, as all 207 code (including the library code in libgcc and libstdc++) must be 208 compiled with the same ABI. 209 210*** Changes in EGCS 1.0: 211 212* A public review copy of the December 1996 Draft of the ISO/ANSI C++ 213 standard is now available. See 214 215 http://www.cygnus.com/misc/wp/ 216 217 for more information. 218 219* g++ now uses a new implementation of templates. The basic idea is that 220 now templates are minimally parsed when seen and then expanded later. 221 This allows conformant early name binding and instantiation controls, 222 since instantiations no longer have to go through the parser. 223 224 What you get: 225 226 + Inlining of template functions works without any extra effort or 227 modifications. 228 + Instantiations of class templates and methods defined in the class 229 body are deferred until they are actually needed (unless 230 -fexternal-templates is specified). 231 + Nested types in class templates work. 232 + Static data member templates work. 233 + Member function templates are now supported. 234 + Partial specialization of class templates is now supported. 235 + Explicit specification of template parameters to function templates 236 is now supported. 237 238 Things you may need to fix in your code: 239 240 + Syntax errors in templates that are never instantiated will now be 241 diagnosed. 242 + Types and class templates used in templates must be declared 243 first, or the compiler will assume they are not types, and fail. 244 + Similarly, nested types of template type parameters must be tagged 245 with the 'typename' keyword, except in base lists. In many cases, 246 but not all, the compiler will tell you where you need to add 247 'typename'. For more information, see 248 249 http://www.cygnus.com/misc/wp/dec96pub/template.html#temp.res 250 251 + Guiding declarations are no longer supported. Function declarations, 252 including friend declarations, do not refer to template instantiations. 253 You can restore the old behavior with -fguiding-decls until you fix 254 your code. 255 256 Other features: 257 258 + Default function arguments in templates will not be evaluated (or 259 checked for semantic validity) unless they are needed. Default 260 arguments in class bodies will not be parsed until the class 261 definition is complete. 262 + The -ftemplate-depth-NN flag can be used to increase the maximum 263 recursive template instantiation depth, which defaults to 17. If you 264 need to use this flag, the compiler will tell you. 265 + Explicit instantiation of template constructors and destructors is 266 now supported. For instance: 267 268 template A<int>::A(const A&); 269 270 Still not supported: 271 272 + Member class templates. 273 + Template friends. 274 275* Exception handling support has been significantly improved and is on by 276 default. The compiler supports two mechanisms for walking back up the 277 call stack; one relies on static information about how registers are 278 saved, and causes no runtime overhead for code that does not throw 279 exceptions. The other mechanism uses setjmp and longjmp equivalents, and 280 can result in quite a bit of runtime overhead. You can determine which 281 mechanism is the default for your target by compiling a testcase that 282 uses exceptions and doing an 'nm' on the object file; if it uses __throw, 283 it's using the first mechanism. If it uses __sjthrow, it's using the 284 second. 285 286 You can turn EH support off with -fno-exceptions. 287 288* RTTI support has been rewritten to work properly and is now on by default. 289 This means code that uses virtual functions will have a modest space 290 overhead. You can use the -fno-rtti flag to disable RTTI support. 291 292* On ELF systems, duplicate copies of symbols with 'initialized common' 293 linkage (such as template instantiations, vtables, and extern inlines) 294 will now be discarded by the GNU linker, so you don't need to use -frepo. 295 This support requires GNU ld from binutils 2.8 or later. 296 297* The overload resolution code has been rewritten to conform to the latest 298 C++ Working Paper. Built-in operators are now considered as candidates 299 in operator overload resolution. Function template overloading chooses 300 the more specialized template, and handles base classes in type deduction 301 and guiding declarations properly. In this release the old code can 302 still be selected with -fno-ansi-overloading, although this is not 303 supported and will be removed in a future release. 304 305* Standard usage syntax for the std namespace is supported; std is treated 306 as an alias for global scope. General namespaces are still not supported. 307 308* New flags: 309 310 + New warning -Wno-pmf-conversion (don't warn about 311 converting from a bound member function pointer to function 312 pointer). 313 314 + A flag -Weffc++ has been added for violations of some of the style 315 guidelines in Scott Meyers' _Effective C++_ books. 316 317 + -Woverloaded-virtual now warns if a virtual function in a base 318 class is hidden in a derived class, rather than warning about 319 virtual functions being overloaded (even if all of the inherited 320 signatures are overridden) as it did before. 321 322 + -Wall no longer implies -W. The new warning flag, -Wsign-compare, 323 included in -Wall, warns about dangerous comparisons of signed and 324 unsigned values. Only the flag is new; it was previously part of 325 -W. 326 327 + The new flag, -fno-weak, disables the use of weak symbols. 328 329* Synthesized methods are now emitted in any translation units that need 330 an out-of-line copy. They are no longer affected by #pragma interface 331 or #pragma implementation. 332 333* __FUNCTION__ and __PRETTY_FUNCTION__ are now treated as variables by the 334 parser; previously they were treated as string constants. So code like 335 `printf (__FUNCTION__ ": foo")' must be rewritten to 336 `printf ("%s: foo", __FUNCTION__)'. This is necessary for templates. 337 338* local static variables in extern inline functions will be shared between 339 translation units. 340 341* -fvtable-thunks is supported for all targets, and is the default for 342 Linux with glibc 2.x (also called libc 6.x). 343 344* bool is now always the same size as another built-in type. Previously, 345 a 64-bit RISC target using a 32-bit ABI would have 32-bit pointers and a 346 64-bit bool. This should only affect Irix 6, which was not supported in 347 2.7.2. 348 349* new (nothrow) is now supported. 350 351* Synthesized destructors are no longer made virtual just because the class 352 already has virtual functions, only if they override a virtual destructor 353 in a base class. The compiler will warn if this affects your code. 354 355* The g++ driver now only links against libstdc++, not libg++; it is 356 functionally identical to the c++ driver. 357 358* (void *)0 is no longer considered a null pointer constant; NULL in 359 <stddef.h> is now defined as __null, a magic constant of type (void *) 360 normally, or (size_t) with -ansi. 361 362* The name of a class is now implicitly declared in its own scope; A::A 363 refers to A. 364 365* Local classes are now supported. 366 367* __attribute__ can now be attached to types as well as declarations. 368 369* The compiler no longer emits a warning if an ellipsis is used as a 370 function's argument list. 371 372* Definition of nested types outside of their containing class is now 373 supported. For instance: 374 375 struct A { 376 struct B; 377 B* bp; 378 }; 379 380 struct A::B { 381 int member; 382 }; 383 384* On the HPPA, some classes that do not define a copy constructor 385 will be passed and returned in memory again so that functions 386 returning those types can be inlined. 387 388*** The g++ team thanks everyone that contributed to this release, 389 but especially: 390 391* Joe Buck <jbuck@synopsys.com>, the maintainer of the g++ FAQ. 392* Brendan Kehoe <brendan@cygnus.com>, who coordinates testing of g++. 393* Jason Merrill <jason@cygnus.com>, the g++ maintainer. 394* Mark Mitchell <mmitchell@usa.net>, who implemented member function 395 templates and explicit qualification of function templates. 396* Mike Stump <mrs@wrs.com>, the previous g++ maintainer, who did most of 397 the exception handling work. 398