Announcement

Collapse
No announcement yet.

LLVM Began Its Dominance Of The Compiler Landscape This Decade

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

  • LLVM Began Its Dominance Of The Compiler Landscape This Decade

    Phoronix: LLVM Began Its Dominance Of The Compiler Landscape This Decade

    Not only has LLVM's Clang compiler proven to become a viable alternative to C/C++ and is now widely used by many different vendors for building production software and nearly at parity for performance to GCC, but the LLVM compiler infrastructure has proven to be a huge success. Beyond Apple as one of the original stakeholders, LLVM is also used by multiple software projects within Intel, AMD is making extensive use of it for their graphics compiler and other purposes, and many other companies leveraging the LLVM projects for various often innovative purposes -- Microsoft is even using it within select projects...

    http://www.phoronix.com/scan.php?pag...010s-Dominance

  • #2
    I think we should be very careful about heaping praise on companies supporting LLVM. The reason isn't because of performance or any other merits of the code base. The reason is because of it's license. Companies that use LLVM based compilers have no obligation of returning their work to upstream. Apple is notorious for taking open source software and ignoring their obligations (ethical if not legal) in returning their work to the wider community. LLVM isn't the only example of that, there's also the anemic practical support for Darwin and FreeBSD. You better believe that the others jumping onboard LLVM are aiming to do the same thing. We're going to end up with fragmented versions of LLVM/Clang/Flang/etc as this progresses as Intel, AMD, Microsoft, Apple, etc all push their own forks with proprietary extensions for their specific platforms.

    While GCC could certainly have been forked, all changes exposed to the public had to be made public, so changes benefit the community at large.
    Last edited by stormcrow; 12-24-2019, 09:38 PM.

    Comment


    • #3
      Originally posted by stormcrow View Post
      Apple is notorious for taking open source software and ignoring their obligations (ethical if not legal) in returning their work to the wider community.
      It is legal. That's the major motivation (imo) that Apple moves away from GPL software.

      In addition.

      Comment


      • #4
        Originally posted by stormcrow View Post
        I think we should be very careful about heaping praise on companies supporting LLVM. The reason isn't because of performance or any other merits of the code base. The reason is because of it's license. Companies that use LLVM based compilers have no obligation of returning their work to upstream.
        For what it's worth, we started using LLVM in part because of the license (in the pre-Clang days pairing a proprietary C++ front end with LLVM back end was common in proprietary drivers) but these days pretty much everything we do goes upstream because it simplifies ongoing maintenance.

        Comment


        • #5
          I don't know why the article at hand fawns over LLVM. Personally, I find LLVM to be an irritating annoyance.

          In the pre-LLVM days, everything compiled and was compatible with gcc. Now I have to deal with two competing compilers, one of which I've never been successfully able to build from source so far (LLVM). I had to make code changes to my apps to accomodate Google's dropping of support for gcc on Android, since LLVM isn't 100% compatible with gcc and inline assembly. And LLVM isn't that great of a compiler -- it doesn't produce faster code in my use of it and compile times aren't any faster than gcc from what I've seen.

          If it wasn't for the megacorps forcing it down on me, I'd uninstall LLVM in a heartbeat.
          Last edited by ed31337; 12-25-2019, 12:45 AM.

          Comment


          • #6
            Originally posted by stormcrow View Post
            I think we should be very careful about heaping praise on companies supporting LLVM. The reason isn't because of performance or any other merits of the code base. The reason is because of it's license. Companies that use LLVM based compilers have no obligation of returning their work to upstream. Apple is notorious for taking open source software and ignoring their obligations (ethical if not legal) in returning their work to the wider community. LLVM isn't the only example of that, there's also the anemic practical support for Darwin and FreeBSD. You better believe that the others jumping onboard LLVM are aiming to do the same thing. We're going to end up with fragmented versions of LLVM/Clang/Flang/etc as this progresses as Intel, AMD, Microsoft, Apple, etc all push their own forks with proprietary extensions for their specific platforms.

            While GCC could certainly have been forked, all changes exposed to the public had to be made public, so changes benefit the community at large.
            Here's the thing: in practice, almost everything done to LLVM has gone upstream. This ranges from compile time improvements by Google so Chromium can build faster to frontend improvements by Microsoft so that they can offer it as part of Visual Studio, not to mention it can now build the kernel because of Google's work primarily.

            Furthermore, the LLVM suite has the advantage that its far more modular than GCC, so you can use the LLVM backend and Clang frontend in your projects. Proprietary products are going to try to parse C++ anyway, why not use a reliable library that can be improved on to the benefit of everyone else? Heck, the library is the reason Clang is so popular amongst even open source IDEs: GCC has no alternative, sans GCC-XML which is quite a mess.

            Comment


            • #7
              Originally posted by ed31337 View Post
              I don't know why the article at hand fawns over LLVM. Personally, I find LLVM to be an irritating annoyance.

              In the pre-LLVM days, everything compiled and was compatible with gcc. Now I have to deal with two competing compilers, one of which I've never been successfully able to build from source so far (LLVM). I had to make code changes to my apps to accomodate Google's dropping of support for gcc on Android, since LLVM isn't 100% compatible with gcc and inline assembly. And LLVM isn't that great of a compiler -- it doesn't produce faster code in my use of it and compile times aren't any faster than gcc from what I've seen.

              If it wasn't for the megacorps forcing it down on me, I'd uninstall LLVM in a heartbeat.
              First off, LLVM is modular. Everything is available as a library that you can embed. This is why many open source code-related projects use libclang for everything: GCC has no alternative.

              When Clang was first released, GCC was also stagnated: the C++ standard support was mixed at best, and the errors were abysmal. Clang's competition is the reason they've picked up their place.

              There's also the LLD linker project, which drastically outperforms binutils's ld.bfd/ld.gold by an order of magnitude. This was largely made possible by LLVM's superior architecture.

              Last but not least...overall LLVM is honestly *easier* to build than GCC. I've built it many times without trouble.

              Comment


              • #8
                The thing is, it’s better to make big companies believe in open source than forcing big companies to open source, for them it’s not that big of deal to make a new one if they don’t like it. And I think that’s where a lot of projects got it wrong and ended up back firing. Like Samba for instance, Apple was contributing until they changed the license from GPLv2 to v3, Apple then decided to make their own implementation of file share. It’s a bit of a psychological game as well that I like to contribute to things I like to contribute to, but when there’s a gun on my head I rather not do the work, in some cases I’d just re-write it so I won’t be forced into anything.

                Comment


                • #9
                  Originally posted by stormcrow View Post
                  ... Companies that use LLVM based compilers have no obligation of returning their work to upstream. Apple is notorious for taking open source software and ignoring their obligations (ethical if not legal) in returning their work to the wider community. ...
                  Dear stromcrow,

                  besides what other people have posted about the obvious practical viability of a BSD license almende, I'd respectfully like to point out to you the ethical dimension of your own post.

                  It is fully legal and ethical, if able-minded and consenting adults go into a contract where one party offers source code without any strings attached and the other party decides to use it. An "ethical obligation" determining future behavior does not result from this action neither for the one nor for the other party, as this would be completely adverse to the "no-strings-attached" intention. If any expectation of re-contribution would have been intended, a different license with different wording could have very well been used. A third party (you, in case this isn't obvious) is not entitled to redefine neither intention nor wording of the agreement of aforementioned parties.

                  However, it is highly unethical and even illegal, at least here in Germany, to badmouth a person or company as a contract breaker "ignoring its obligations" (unless that would be very clearly the case and be issued as a statement of fact). So please, take a look in the mirror and try to apply your high ethical standards to yourself (Matthew 7:3-5).

                  Best regards.

                  Comment


                  • #10
                    Originally posted by brad0
                    I was going to write a reply and then decided fuck it. You're a typical ignorant troll. Fuck off.
                    No, you fuck off.

                    Comment

                    Working...
                    X