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