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