GCC 7.5
gcc.gnu.org
gcc.gnu.org
>This is also the last release from the GCC 7 branch which will receive no further fixes from now on. GCC continues to be maintained on the GCC 8 and GCC 9 branches and the development trunk.
GCC is an important piece of software, probably as important as the Linux kernel, but by now I presume it should have become a gigantic pile of outdated and barely maintainable code. Unless I'm wrong of course!
Competition is a good thing, even in open source.
But the answer is because GitHub doesn't distinguish what is and isn't a mirror (last I checked there was no mirror functionality like GitLab or Gitea). Plus, I don't think they let you disable PRs.
They do. See the "mirrored from" text near the top of the page. These unmaintained mirrors, which GitHub created and no one owns, just collected PRs from well-intentioned users, and it's up to random other people or the maintainers of the project to go tell them how to submit properly. I've emailed GitHub support about this, as it hits the Wine project, too[1], but they refuse to do anything.
It feels like a dark pattern, to try to make GitHub the one-and-only source for open source projects. One of several reasons I dislike GitHub and wish it wasn't so well embraced by the open source community.
[0]: https://github.com/nss-dev/nss [1]: https://github.com/videolan/vlc
No doubt only the best developers can work on something like a compiler or an OS kernel. A lot of the times though OSS gets worse over time or is not improving at all. That includes some important desktop apps like Audacity and Inkscape. Both look like shit, buggy as hell, codebase is a mess, not improving over time, but their existence itself is important.
Not extrapolating this to GCC because I'm not familiar with its source any more.
> If that does not describe the quality of your own work you have some improving to do
My comment was tongue in cheek in case you didn't get it. Least of all I need unsolicited advice and moralizing.
> When good developers work on something it should get better over time.
Which is obviously wrong as a generalization. Again, I have nothing against GCC and its team, but codebases in general do tend to get worse over time or at least between complete rewrites, especially when it's a collective effort and especially if it's voluntary open source work, no matter how important it can be.
Having been in this industry for 30 years I firmly believe that bugs should be fixed by those who introduced them.
This:
GCC 7.5 is a bug-fix release from the GCC 7 branch
containing important fixes for regressions and serious bugs in
GCC 7.4 with more than 215 bugs fixed since the previous release.
is not normal (215 bugs!) and no, I'm not going to go and pick a bug to fix in this source code. I'd rather contribute to LLVM which seems much cleaner and higher quality overall.Whereas the way it should be is: you are responsible for testing your own code and changes, not users, not your QA department. You are personally responsible. Of course you will make mistakes, but not 200 at a time. You might have multiple issues in your code, but it is fine as long as you have tested as much as you could before committing/pushing.
In other words, if that statement is false, it follows that software products can only improve if left to languish (i.e. bitrot must have a positive effect), or if the product is worked on by bad developers. And why would they be called bad developers if they succeed in improving the product they work on?
Well isn't that exactly what you are doing?
Not so sure about that. I remember developing and building some huge projects with 3.4 at the time. I don't recall any major bugs in the compiler.
The only problem was that the C++ compiler was rather slow compared to competition.
Of course rewind a few years behind that and you had the "egcs" fork that eventually got merged back?
GCC is only slightly older than Linux or BSD. Do you think those programs are gigantic piles of outdated and barely maintainable code?
GCC produces the faster code than clang by a significant margin. (ICC produces faster code than GCC, but you need to pay for it and buy Intel hardware. MSVC is obviously garbage.) Its LTO optimizes more stuff than clang's, despite clang pioneering the idea. So sure, it's old, but it's best in class at what it does.
2.95 brings back memories though. It's why I switched from Slackware to Gentoo. Some random application I used didn't compile with 2.95 and required gcc-3. But configuring gcc-3 was still a huge pain with most distros, Gentoo was literally the only one where gcc-3 could be configured as the primary compiler. Those were the days.
https://gcc.gnu.org/develop.html#timeline gives a good picture of how gcc releases work.
https://gcc.gnu.org/gcc-7/changes.html is about the entire GNU 7 series, but it's not broken down by release. The list of tickets closed is mentioned at the bottom:
> GCC 7.5: This is the [ https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED... ](list of problem reports (PRs)) from GCC's bug tracking system that are known to be fixed in the 7.5 release. This list might not be complete (that is, it is possible that some PRs that have been fixed are not listed here).
GCC has been less aggressive compared to clang in adding diagnostics to -Wall that trigger on correct code; -Wno-missing-field-initializers and -Wno-override-init come to mind, but those predate 4.7. -Wexpansion-to-defined is super annoying, but that came much later (GCC 8?), and strictly speaking it triggers on undefined behavior--it's just that the undefined behavior was extremely convenient, pre-dated GCC, reliably supported (at least for the most common and possibly only usages) on almost all if not all major compilers, and is the only possible approach for writing lazy feature detection macros that can be defined in library headers without include'ing possibly unused headers, polluting the namespace.
Note that GCC 5 switched from c99 by default to c11 by default. This isn't "just" a compiler flag, and it's not a GCC problem either, you'll have the same problem in clang or ICC. Try upgrading and compiling with -std=c99. (or -std=gnu99 if that's your thing) You might find that gcc-9 works if you feed it the right standard of C.
Compiler updates occasionally remove certain definitions from headers that aren't supposed to contain those definitions. For instance, lots of headers contain the definition for size_t, but only stddef.h is required to. Occasionally an update will hit that removes it from I dunno, rand.h or whatever. This is a good thing; headers shouldn't contain a bunch of extra crap in then. In those cases, it's because your code was always broken, not that the compiler upgrade broke it. Blaming the compiler in that case is like blaming QA. Which, to be fair, it was QA's fault.
My intent wasn't to criticize gcc, but I think 7 years is not that long of a life-time for non-trivial software.