Announcement

Collapse
No announcement yet.

GCC 12.4 Compiler Released With 84+ Bugs Fixed

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • GCC 12.4 Compiler Released With 84+ Bugs Fixed

    Phoronix: GCC 12.4 Compiler Released With 84+ Bugs Fixed

    For those continuing to rely on the GCC 12 series open-source compiler that was introduced as stable in 2022, GCC 12.4 is out today as the newest bug fix release...

    Phoronix, Linux Hardware Reviews, Linux hardware benchmarks, Linux server benchmarks, Linux benchmarking, Desktop Linux, Linux performance, Open Source graphics, Linux How To, Ubuntu benchmarks, Ubuntu hardware, Phoronix Test Suite

  • #2
    GCC 12.4 brings an assortment of bug fixes that have built up in the GCC 12 compiler branch over the past year. There have been more than 84 bug fixes back-ported to the GCC 12 codebase in the past thirteen months.
    There should never be any need for bug fixes in a compiler.

    If you can't trust the software that is used to build the binaries you use them how can you trust the binaries themselves?

    Bugs in a compiler means that even if I write the most perfect code ever seen, using every single best coding practice, there's still the possibility that the resulting binary will have bugs.

    Even worse, since there is no change log per se, it's very difficult to see the extent of the potential damage but 84+ bugs is significant.

    Imagine being a developer of a program and you get blamed for an issue that is discovered while using your software that is not actually your fault but rather the compiler you used.

    If there is one piece of software that you should be able to rely on it's the compiler.

    Comment


    • #3
      Originally posted by sophisticles View Post
      There should never be any need for bug fixes in a compiler.

      If you can't trust the software that is used to build the binaries you use them how can you trust the binaries themselves?
      Compilers are software, software is buggy. Obviously, compiler developers take great care to not introduce bugs, but compilers are complex beasts (linkers too), so there will always be bugs here and there.

      Not saying that bugs in compilers are cool, just that your demand is unreasonable. Fortunately, most compiler tool sets work well in most circumstances.

      Comment


      • #4
        Originally posted by sophisticles View Post

        There should never be any need for bug fixes in a compiler.

        If you can't trust the software that is used to build the binaries you use them how can you trust the binaries themselves?

        Bugs in a compiler means that even if I write the most perfect code ever seen, using every single best coding practice, there's still the possibility that the resulting binary will have bugs.

        Even worse, since there is no change log per se, it's very difficult to see the extent of the potential damage but 84+ bugs is significant.

        Imagine being a developer of a program and you get blamed for an issue that is discovered while using your software that is not actually your fault but rather the compiler you used.

        If there is one piece of software that you should be able to rely on it's the compiler.


        While in principle I agree with you, unfortunately if someone had a rule to use only compilers known to be bug-free, the result would be that there would be no such compilers from which to choose.

        Gcc is far from being the buggiest compiler. Maybe I have been lucky, but I have never experienced one of the many gcc bugs (except some that did not affect program correctness but which only reduced the performance), but I have encountered a few cases where the Microsoft Visual C++ compiler has generated incorrect code.

        Good tests will catch not only the programming errors, but also the compiler bugs, even if the latter are much more annoying, because they complicate the interpretation of the test results, so typically much more time is wasted until discovering the cause of an error.

        Comment


        • #5
          GCC is massive. That's 84 bugs across many, many architectures and languages and sub-projects. Having hacked on GCC a bit with SuperH, one of the lesser used architectures which could use some love, it's absolutely amazing that new optimizations and new language frontends can be added to GCC and taken advantage of on those archs with pretty much no extra specific work per arch. But then at the same time if there is a unique edge quirk to one specific ABI of one specific sub-architecture and some library within some sub-project doesn't like that quirk, that's a bug. If some architecture has an unusual quirk of register allocation then some optimization changes elsewhere might result in a slight regression in code quality (albeit still working), that's a bug. So given the massive complexity and layers of GCC I would say 84 bugs is nothing.

          Comment


          • #6
            Originally posted by sophisticles View Post

            There should never be any need for bug fixes in a compiler.

            If you can't trust the software that is used to build the binaries you use them how can you trust the binaries themselves?

            Bugs in a compiler means that even if I write the most perfect code ever seen, using every single best coding practice, there's still the possibility that the resulting binary will have bugs.

            Even worse, since there is no change log per se, it's very difficult to see the extent of the potential damage but 84+ bugs is significant.

            Imagine being a developer of a program and you get blamed for an issue that is discovered while using your software that is not actually your fault but rather the compiler you used.

            If there is one piece of software that you should be able to rely on it's the compiler.
            Well, it looks like a bait, but I'll bite, anyway.

            If you are so worried that your "perfect code" can be tainted by gcc or llvm, I suggest you escalate your worries a bit more, as your "perfect code" can be affected by your processor, because they too can go to la-la land under corner circumstances. Better yet, I suggest you to stop using computers, because on them there are many other corner cases that can misbehave when running your "perfect code".

            In the end, I suspect you hit your objective, i.e., get replies.

            Comment


            • #7
              Originally posted by acobar View Post

              Well, it looks like a bait, but I'll bite, anyway.

              If you are so worried that your "perfect code" can be tainted by gcc or llvm, I suggest you escalate your worries a bit more, as your "perfect code" can be affected by your processor, because they too can go to la-la land under corner circumstances. Better yet, I suggest you to stop using computers, because on them there are many other corner cases that can misbehave when running your "perfect code".

              In the end, I suspect you hit your objective, i.e., get replies.
              It amazes me that OSS zealots will defend any OSS shortcoming no matter how absurd it is.

              Comment


              • #8
                I have always considered Intel compilers to be the best quality but even Intel is based on LLVM now. Both Intel and AMD (also ARM) rely on GCC and LLVM; they regularly update and submit their new product support to open source. I never used or needed MS compilers and I am not going to be surprised when/if they switch to open source compilers.

                Comment


                • #9
                  Originally posted by sophisticles View Post

                  It amazes me that OSS zealots will defend any OSS shortcoming no matter how absurd it is.
                  you think closed source compilers fare better? comparing existing OSS software to a non-existing ideal is pretty pointless.

                  Comment


                  • #10
                    Originally posted by sophisticles View Post

                    It amazes me that OSS zealots will defend any OSS shortcoming no matter how absurd it is.
                    I am a good troller sometimes, but I must admit, even I have some trouble trying to understand if you believe what you say or if you are just laughing your ass off each time someone bites on your trolling.

                    In any case, it is good quality trolling. Well done!

                    Comment

                    Working...
                    X