@
1.1.1.1
log
@initial import of GCC 4.5.3 sources. changes since 4.1 are way too numerous
to review, please see http://gcc.gnu.org/gcc-4.5/changes.html (and the 4.2,
4.3 and 4.4 versions, too.)
this includes the core, c++, objc and the non java/ada/fortran parts of the
testsuite.
@
text
@@
1.1.1.1.8.1
log
@Rebase to HEAD as of a few days ago.
@
text
@d2 2
a3 1
Chapter 11. Algorithms
The neatest accomplishment of the algorithms section is that all the
work is done via iterators, not containers directly. This means two
important things:
Anything that behaves like an iterator can be used in one of
these algorithms. Raw pointers make great candidates, thus
built-in arrays are fine containers, as well as your own
iterators.
The algorithms do not (and cannot) affect the container as a
whole; only the things between the two iterator endpoints. If
you pass a range of iterators only enclosing the middle third of
a container, then anything outside that range is inviolate.
Even strings can be fed through the algorithms here, although the
string class has specialized versions of many of these functions
(for example, string::find()). Most of the examples
on this page will use simple arrays of integers as a playground
for algorithms, just to keep things simple. The use of
N as a size in the examples is to keep things
easy to read but probably won't be valid code. You can use wrappers
such as those described in
the containers section to keep
real code readable.
The single thing that trips people up the most is the definition
of range used with iterators; the famous
"past-the-end" rule that everybody loves to hate. The
iterators section of this
document has a complete explanation of this simple rule that seems
to cause so much confusion. Once you
get range into your head (it's not that hard,
honest!), then the algorithms are a cakewalk.
Mutating
swap
Specializations
If you call std::swap(x,y); where x and y are standard
containers, then the call will automatically be replaced by a call to
x.swap(y); instead.
This allows member functions of each container class to take over, and
containers' swap functions should have O(1) complexity according to
the standard. (And while "should" allows implementations to
behave otherwise and remain compliant, this implementation does in
fact use constant-time swaps.) This should not be surprising, since
for two containers of the same type to swap contents, only some
internal pointers to storage need to be exchanged.
@
1.1.1.1.2.1
log
@sync with head.
for a reference, the tree before this commit was tagged
as yamt-pagecache-tag8.
this commit was splitted into small chunks to avoid
a limitation of cvs. ("Protocol error: too many arguments")
@
text
@d2 2
a3 1
Chapter 11. Algorithms
The neatest accomplishment of the algorithms section is that all the
work is done via iterators, not containers directly. This means two
important things:
Anything that behaves like an iterator can be used in one of
these algorithms. Raw pointers make great candidates, thus
built-in arrays are fine containers, as well as your own
iterators.
The algorithms do not (and cannot) affect the container as a
whole; only the things between the two iterator endpoints. If
you pass a range of iterators only enclosing the middle third of
a container, then anything outside that range is inviolate.
Even strings can be fed through the algorithms here, although the
string class has specialized versions of many of these functions
(for example, string::find()). Most of the examples
on this page will use simple arrays of integers as a playground
for algorithms, just to keep things simple. The use of
N as a size in the examples is to keep things
easy to read but probably won't be valid code. You can use wrappers
such as those described in
the containers section to keep
real code readable.
The single thing that trips people up the most is the definition
of range used with iterators; the famous
"past-the-end" rule that everybody loves to hate. The
iterators section of this
document has a complete explanation of this simple rule that seems
to cause so much confusion. Once you
get range into your head (it's not that hard,
honest!), then the algorithms are a cakewalk.
Mutating
swap
Specializations
If you call std::swap(x,y); where x and y are standard
containers, then the call will automatically be replaced by a call to
x.swap(y); instead.
This allows member functions of each container class to take over, and
containers' swap functions should have O(1) complexity according to
the standard. (And while "should" allows implementations to
behave otherwise and remain compliant, this implementation does in
fact use constant-time swaps.) This should not be surprising, since
for two containers of the same type to swap contents, only some
internal pointers to storage need to be exchanged.
@
1.1.1.2
log
@import GCC 4.8 branch at r206687.
highlights from: http://gcc.gnu.org/gcc-4.6/changes.html
GCC now has stricter checks for invalid command-line options
New -Wunused-but-set-variable and -Wunused-but-set-parameter
warnings
Many platforms have been obsoleted
Link-time optimization improvements
A new switch -fstack-usage has been added
A new function attribute leaf was introduced
A new warning, enabled by -Wdouble-promotion
Support for selectively enabling and disabling warnings via
#pragma GCC diagnostic has been added
There is now experimental support for some features from the
upcoming C1X revision of the ISO C standard
Improved experimental support for the upcoming C++0x ISO C++
standard
G++ now issues clearer diagnostics in several cases
Updates for ARM, x86, MIPS, PPC/PPC64, SPARC
Darwin, FreeBSD, Solaris 2, MinGW and Cygwin now all support
__float128 on 32-bit and 64-bit x86 targets. [*1]
highlights from: http://gcc.gnu.org/gcc-4.7/changes.html
The -fconserve-space flag has been deprecated
Support for a new parameter --param case-values-threshold=n
was added
Interprocedural and Link-time optimization improvements
A new built-in, __builtin_assume_aligned, has been added
A new warning option -Wunused-local-typedefs was added
A new experimental command-line option -ftrack-macro-expansion
was added
Support for atomic operations specifying the C++11/C11 memory
model has been added
There is support for some more features from the C11 revision
of the ISO C standard
Improved experimental support for the new ISO C++ standard,
C++11
Updates for ARM, x86, MIPS, PPC/PPC64, SH, SPARC, TILE*
A new option (-grecord-gcc-switches) was added
highlights from: http://gcc.gnu.org/gcc-4.8/changes.html
GCC now uses C++ as its implementation language. This means
that to build GCC from sources, you will need a C++
compiler that understands C++ 2003
DWARF4 is now the default when generating DWARF debug
information
A new general optimization level, -Og, has been introduced
A new option -ftree-partial-pre was added
The option -fconserve-space has been removed
The command-line options -fipa-struct-reorg and
-fipa-matrix-reorg have been removed
Interprocedural and Link-time optimization improvements
AddressSanitizer, a fast memory error detector, has been
added [*2]
A new -Wsizeof-pointer-memaccess warning has been added
G++ now supports a -std=c++1y option for experimentation
with features proposed for the next revision of the
standard, expected around 2014
Improved experimental support for the new ISO C++ standard,
C++11
A new port has been added to support AArch64
Updates for ARM, x86, MIPS, PPC/PPC64, SH, SPARC, TILE*
[*1] we should support this too!
[*2] we should look into this.
https://code.google.com/p/address-sanitizer/
@
text
@d2 2
a3 1
Chapter 11. Algorithms
The neatest accomplishment of the algorithms section is that all the
work is done via iterators, not containers directly. This means two
important things:
Anything that behaves like an iterator can be used in one of
these algorithms. Raw pointers make great candidates, thus
built-in arrays are fine containers, as well as your own
iterators.
The algorithms do not (and cannot) affect the container as a
whole; only the things between the two iterator endpoints. If
you pass a range of iterators only enclosing the middle third of
a container, then anything outside that range is inviolate.
Even strings can be fed through the algorithms here, although the
string class has specialized versions of many of these functions
(for example, string::find()). Most of the examples
on this page will use simple arrays of integers as a playground
for algorithms, just to keep things simple. The use of
N as a size in the examples is to keep things
easy to read but probably won't be valid code. You can use wrappers
such as those described in
the containers section to keep
real code readable.
The single thing that trips people up the most is the definition
of range used with iterators; the famous
"past-the-end" rule that everybody loves to hate. The
iterators section of this
document has a complete explanation of this simple rule that seems
to cause so much confusion. Once you
get range into your head (it's not that hard,
honest!), then the algorithms are a cakewalk.
Mutating
swap
Specializations
If you call std::swap(x,y); where x and y are standard
containers, then the call will automatically be replaced by a call to
x.swap(y); instead.
This allows member functions of each container class to take over, and
containers' swap functions should have O(1) complexity according to
the standard. (And while "should" allows implementations to
behave otherwise and remain compliant, this implementation does in
fact use constant-time swaps.) This should not be surprising, since
for two containers of the same type to swap contents, only some
internal pointers to storage need to be exchanged.
@
1.1.1.3
log
@import GCC 5.3.0. see these urls for details which are too large to
include here:
http://gcc.gnu.org/gcc-4.9/changes.html
http://gcc.gnu.org/gcc-5/changes.html
(note that GCC 5.x is a release stream like GCC 4.9.x, 4.8.x, etc.)
the main issues we will have are:
The default mode for C is now -std=gnu11 instead of -std=gnu89.
ARM:
The deprecated option -mwords-little-endian has been removed.
The options -mapcs, -mapcs-frame, -mtpcs-frame and -mtpcs-leaf-frame
which are only applicable to the old ABI have been deprecated.
MIPS:
The o32 ABI has been modified and extended. The o32 64-bit
floating-point register support is now obsolete and has been removed.
It has been replaced by three ABI extensions FPXX, FP64A, and FP64.
The meaning of the -mfp64 command-line option has changed. It is now
used to enable the FP64A and FP64 ABI extensions.
@
text
@d9 1
a9 1
@
1.1.1.3.16.1
log
@Sync with HEAD
@
text
@d2 1
a2 1
Chapter 11. Algorithms
Chapter 11.
@
1.1.1.3.14.1
log
@Sync with HEAD, resolve a couple of conflicts
@
text
@d2 1
a2 1
Chapter 11. Algorithms
Chapter 11.
@
1.1.1.4
log
@import GCC 6.5.0. this is largely a maint release with no
particularly features listed here:
http://gcc.gnu.org/gcc-6/changes.html
this fixes over 250 PRs in the GCC bugzilla:
https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=6.5
@
text
@d2 1
a2 1
Chapter 11. Algorithms