gcc

The distinctions are quite arbitrary since there currently isn't anything like a size-competition for compilers, but if forced to make categories, I'd consider <1kLoC to be "tiny" and <10kLoC "small". In contrast, GCC is nearing 10MLoC - 4 orders of magnitude difference - and its C parser alone is >10kLoC: https://github.com/gcc-mirror/gcc/blob/master/gcc/c/c-parser...

Generally speaking the heavy part of both exceptions and rtti are in codegen (ie. the amount of code generated by the compiler), not in the 'runtime'. Exception jump tables and typeinfo objects are calculated as part of the compile and just referred to at run time. For example, this is the part of libsupc++ (effectively gnu's c++ "runtime") that deals with throwing: https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-...

GCC hasn't had "a" maintainer since the late '90s, when RMS stopped being sole maintainer. It's now maintained by a whole bunch of people: https://github.com/gcc-mirror/gcc/blob/master/MAINTAINERS

Are you talking about this? https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-... Do you know what the time complexity of their merging algorithm is? As a side note, an optimal merging algorithm is in the paper called "On Optimal and Efficient in Place Merging", and it's too complicated for me to expect it in a standard library implementation. (Although the STL doesn't need to be optimal, I think the sub-optimal linear-time algorithms are also complicated enough to not be used for the standard library, but correct me if I'm wrong.)

http://gcc.gnu.org/ml/gcc-patches/2012-03/msg00049.html Search for "Here's a nickel" [edit: clearer source than the text around the patch: https://github.com/gcc-mirror/gcc/blob/master/libgcc/soft-fp...]

Are you sure? You're not allowed to invalidate iterators or pointers to elements in a deque, so it shouldn't be reallocating memory (aside from its underlying map of nodes, which will need to grow very rarely). Libstdc++ describes how it's implemented here: https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-... Libc++ doesn't have as descriptive a comment but it's impemented basically the same way here https://github.com/llvm-mirror/libcxx/blob/master/include/de...

Sometimes in a git project there are self explanatory changes that may not require a commit message (ex 'Update README.md'). 'cmt' it's not a replacement for the normal git commit workflow it's just an extra tool that should not be abused but it may result useful when your push doesn't need any special explanation. Here you can see some examples of git commit messages on real world applications that might have been replaced by a 'cmt' commit: - backbone https://github.com/jashkenas/backbone/commit/49123e9ab1d2ef5... ('Don't be clever') - angularjs https://github.com/angular/angular.js/commit/5533e48dead5cff... ('work in progress') - emberjs https://github.com/emberjs/ember.js/commit/0f50e9564c04bc641... ('more goodness') - django https://github.com/django/django/commit/3e2edad9c7c6b980bbc1... ('Missed one') - gcc https://github.com/mirror

Since it's trivia we're dealing with. This commit was made 18 days before I was born: https://github.com/mirrors/gcc/commit/cbbca02e2430b2dc1f5681... :)

It was 16 lines in 1992. I guess that's not what it is today, but not exactly "so small". https://github.com/mirrors/gcc/blob/42c63e4d48cfac192be8c0cc... The copyright notice goes back to '87. I wonder if '92 is just where the source control kicks in.

Trivia: This code is older than many of the readers. https://github.com/mirrors/gcc/blame/7057506456ba18f080679b2...

For future reference, you can link to a specific line in github with #LNNN. Which you can get by clicking on the line number. Pretty handy. https://github.com/mirrors/gcc/blob/master/libgcc/libgcc2.c#...

Looking at the GCC source [1] starting at line 150 this is almost what GCC actually does - perform the multiplication with twice the operand size and then check by shifting right but GCC compares the result of two shift operations differing by one in the shift amount. [1] https://github.com/mirrors/gcc/blob/master/libgcc/libgcc2.c

You can see the implementation in GCC here [1], for example addition starting on line 74. What machine code gets emitted for that obviously depends on the target architecture but it is reasonable to assume that the optimizer recognizes these patterns and uses hardware flags where available. [1] https://github.com/mirrors/gcc/blob/master/libgcc/libgcc2.c