OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [cp/] [NEWS] - Blame information for rev 283

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 283 jeremybenn
*** 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::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
   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 , the maintainer of the g++ FAQ.
396
* Brendan Kehoe , who coordinates testing of g++.
397
* Jason Merrill , the g++ maintainer.
398
* Mark Mitchell , who implemented member function
399
  templates and explicit qualification of function templates.
400
* Mike Stump , the previous g++ maintainer, who did most of
401
  the exception handling work.
402
 
403
 
404
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003,
405
2005 Free Software Foundation, Inc.
406
 
407
Copying and distribution of this file, with or without modification,
408
are permitted in any medium without royalty provided the copyright
409
notice and this notice are preserved.

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.