Announcement

Collapse
No announcement yet.

C++11 & The Long-Term Viability Of GCC Is Questioned

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

  • #61
    Android bootloader can be "unlocked" by pressing certain buttons while booting. Just saying ..

    Comment


    • #62
      Can Clang/LLVM rebuild a whole distro like Gentoo from source? If not it's still a toy.

      Comment


      • #63
        Originally posted by linux5850 View Post
        Can Clang/LLVM rebuild a whole distro like Gentoo from source? If not it's still a toy.
        It can rebuild all of FreeBSD, and most of Debian. The only packages that it fails on are those that rely on non-standard GCC extensions: the kernel is one of those packages. But every release gets better, more extensions get support. (There's actually a patch set out right now to both llvm/clang and the kernel that allow clang to build the kernel, so it IS possible) It won't be too long, probably 2 releases from now, when you CAN build all of debian or gentoo, kernel included, with clang without any patches necessary.

        Comment


        • #64
          Originally posted by linux5850 View Post
          Can Clang/LLVM rebuild a whole distro like Gentoo from source? If not it's still a toy.
          I built my whole system from sources using just Clang ... and with Gentoo (when I used it; not-so-long-ago) I compiled *most* of it (can't remember exact numbers, but grub and linux kernel weren't on the list *for sure*)

          Regards.

          Comment


          • #65
            Originally posted by linux5850 View Post
            Can Clang/LLVM rebuild a whole distro like Gentoo from source? If not it's still a toy.
            Even if it couldn't, it can build 21000 of 24000 3rd party applications in FreeBSD ports.

            https://wiki.freebsd.org/PortsAndClang

            Those remaining 3000 may have inter-dependencies, so it may not have failed on every single one of those remaining 3000.

            Comment


            • #66
              Nonsense

              Nonsense I say.

              - C++: static analyzers
              - code re-formatters,
              - syntax highlighters

              These functions should be done by a separate standalone tool for each task, that is the UNIX/POSIX way of doing things, not the compiler or the compiler backend. A C compiler should produce assembler output, nothing else.

              Ofcause full C++11 support is a nice thing to have. But there is no hurry, the C++11 standard is still new.

              Comment


              • #67
                Originally posted by skies View Post
                Nonsense I say.

                - C++: static analyzers
                - code re-formatters,
                - syntax highlighters

                These functions should be done by a separate standalone tool for each task, that is the UNIX/POSIX way of doing things, not the compiler or the compiler backend. A C compiler should produce assembler output, nothing else.

                Ofcause full C++11 support is a nice thing to have. But there is no hurry, the C++11 standard is still new.
                To follow the UNIX/POSIX way of doing things GCC should consist of at least three modules: front-end, optimizer, back-end. Where you have standalone language specific front-ends and hardware specific back-ends processing/producing an IR. To allow more code sharing and aggressive optimization you may also want to split Linker, Link Time Optimizer, Code Generators.

                This is the idea behind LLVM, a compiling library implementing dozens separate components. It simplifies the job of writing compilers. For example, it took only about two weeks to implement a OpenGL/GLSL JIT compiler using LLVM.

                Try to do the same with GCC. Static analyzers, re-formatters, highlighters are just the icing on the cake...

                Comment


                • #68
                  Originally posted by log0 View Post
                  This is the idea behind LLVM, a compiling library implementing dozens separate components. It simplifies the job of writing compilers. For example, it took only about two weeks to implement a OpenGL/GLSL JIT compiler using LLVM.
                  You mean the one that still isn't fully working after like, a year? RADEON_LLVM?

                  Comment


                  • #69
                    Originally posted by XorEaxEax View Post
                    I mentioned GPL and Apple's licence incompability since they are both copy-left. As for FreeBSD's base system, they are (for ideological reasons) purging their base system of GPL licenced code. https://wiki.freebsd.org/GPLinBase
                    As opposed to Google's "no GPL in userspace" policy which isn't ideological at all.

                    Comment


                    • #70
                      Originally posted by carewolf View Post
                      No, no and no.

                      Maybe I am biased being an actualWebKit developer, but there is no such process happening at any level, and you obviously have misunderstood what WebKit2 is since it is simply a new API for WebCore, not a new project or replacement for any code except interface code.

                      KHTML -> WebCore
                      WebKit(1) old API for WebCore, used by Chromium, Qt and iOS
                      WebKit2 new API for WebCore, used by Safari and Qt.
                      I thought that we were talking about WebKit, not WebCore.

                      Originally posted by linux5850 View Post
                      Can Clang/LLVM rebuild a whole distro like Gentoo from source? If not it's still a toy.
                      We are gradually working toward fixing that. It is not a high priority project though.

                      Originally posted by vertexSymphony View Post
                      I built my whole system from sources using just Clang ... and with Gentoo (when I used it; not-so-long-ago) I compiled *most* of it (can't remember exact numbers, but grub and linux kernel weren't on the list *for sure*)

                      Regards.
                      Linux, GRUB and glibc are the main things that won't build with Clang. Recent versions of binutils will not build with Clang either. That is due to a bug in Clang.

                      Originally posted by skies View Post
                      Nonsense I say.

                      - C++: static analyzers
                      - code re-formatters,
                      - syntax highlighters

                      These functions should be done by a separate standalone tool for each task, that is the UNIX/POSIX way of doing things, not the compiler or the compiler backend. A C compiler should produce assembler output, nothing else.

                      Ofcause full C++11 support is a nice thing to have. But there is no hurry, the C++11 standard is still new.
                      Go write separate utilities for each and get back to us.

                      Comment


                      • #71
                        Originally posted by XorEaxEax View Post
                        The reason they can't put it in the garage for two years is because so much open source infrastructure depends on it, not only to exist as it is now with bug fixes, but to progress with cpu architecture support, language support, standards support, platform support etc.
                        Pardon me for saying, but its not like SW development is going to screech to a halt if C++1x support isn't added for a few months.

                        Comment


                        • #72
                          Originally posted by curaga View Post
                          You mean the one that still isn't fully working after like, a year? RADEON_LLVM?
                          Nice try, but no. If you want to complain about RADEON_LLVM, then AMD/Mesa driver guys are the ones to go to.

                          Btw even if not ready yet, isn't it cool to have a compiler with GPU back-ends? I hope INTEL will follow AMD here.

                          Comment


                          • #73
                            Originally posted by BeardedGNUFreak View Post
                            It shouldn't surprise anyone that the viral GPL license us is dying and free BSD style licenses are rapidly on the rise.

                            The GPL has become synonymous with failure:

                            * GPL Mozilla Firefox got taken out by BSD licensed Chrome

                            * GPL licensed Linux cellphone OSes got take out by BSD licensed Android

                            * GPL licensed GCC has been made into a joke compared to the modern Clang/LLVM toolchain.

                            It is hilarious to see the incompetent GCC clowns shitting themselves as Clang/LLVM has exploded in use and development. Funny how now that developers and companies are free of the garbage GPL that there has been an explosion in code sharing and massive leaps forward in compiler development with Clang/LLVM.
                            Good joke! GPL is synonymous of success and BSD is a synonymous of big failure. BSD was in the game till GPL Linux has come. Linux killed BSD, but some necromancers keep this shit undead. Android isn't BSD, so get your facts straight. Mozilla isn't GPL... Clang/LLVM is a toy compared to GCC which compiles much more software for much more architectures and which is faster. Go home, because BSD is meaningless.

                            Comment


                            • #74
                              Originally posted by Pawlerson View Post
                              Good joke! GPL is synonymous of success and BSD is a synonymous of big failure. BSD was in the game till GPL Linux has come. Linux killed BSD, but some necromancers keep this shit undead. Android isn't BSD, so get your facts straight. Mozilla isn't GPL... Clang/LLVM is a toy compared to GCC which compiles much more software for much more architectures and which is faster. Go home, because BSD is meaningless.
                              GPL use is decreasing, Apache, MIT, and BSD are increasing. http://osrc.blackducksoftware.com/data/licenses/

                              Comment


                              • #75
                                Originally posted by Pawlerson View Post
                                Good joke! GPL is synonymous of success and BSD is a synonymous of big failure. BSD was in the game till GPL Linux has come. Linux killed BSD, but some necromancers keep this shit undead. Android isn't BSD, so get your facts straight. Mozilla isn't GPL... Clang/LLVM is a toy compared to GCC which compiles much more software for much more architectures and which is faster. Go home, because BSD is meaningless.
                                May I point out that quite some embedded devices use BSD (I worked on quite some), of most of them you'll just never realize. Also, since OSX is a "BSD" by heart, I wouldn't really dare to call it a failure. It has a larger desktop market share than linux (servers offc is another thing). And if you're talking about licenses, I think GPLv3 was a major mistake, and a huge turnoff for a lot of developers. There is a reason Linus refuses to adopt GPLv3 for the kernel, and I completely share his point of view.

                                And if you're talking compilers, clang is in a lot of areas far superior to GCC, certainly from the point of view of a developer. Clang is just a joy to work with. A lot faster compiles, certainly when using template code, and actual meaningful errors which most of the time point to exactly the right problem. Not 4 pages of meaningless spaghetti errors for 1 forgotten ";" in old template code you haven't changed in months, which GCC compiled just fine just because you didn't use that specific specialization anywhere until then. I've been there, happy hunting if you're in that situation. I can only recommend setting the CC environment variable to "clang" and CXX to "clang++" in a case like that, it'll save you some time. It errors catches any template code, used or not, unlike GCC.
                                In fact, clang right now is my default compiler in my development environment. And while clang's 'scan-build' static analyzer isn't as far as I hoped, it does some things well and is improved every release. Something like this is doesn't even exist in the gcc tool-chain. If more and more developers discover what day-to-day advantages clang has over GCC, it will get used more and more, at the expense of GCC.

                                GCC still has an edge over clang regarding optimizations and platforms it compiles on/for, but LLVM is a lot more flexible, and has a cleaner code-base (which is normal for such a young project). Don't ridicule clang, because it WILL catch up, and this will happen faster than most people expect.

                                So GPL winning? As long as developers stand behind it, and I'm afraid it's going to lose ground here.

                                Comment

                                Working...
                                X