LWN: Comments on "GCC 10.1 Released"

GCC 10.1 Released

flussence — Tue, 28 Jul 2020 08:30:23 +0000

That would be nice to see. The GPL was written for a US audience, I'd imagine EU law sucks less for the little people.

GCC 10.1 Released

Wol — Sat, 18 Jul 2020 11:10:22 +0000

I'm not sure you're right there.

If I can claim your actions have damaged me, I have a claim against you. If the GPL says you have to give me a copy of the source, certainly under - I think it's now called the Consumer Rights Act (used to be Sale of Goods and Services) - I could sue you for providing faulty/incomplete goods. And if I was damaged by them I can go for damages, never mind that the goods were free. The GPL's disclaimer of warranty wouldn't apply because the suit would say you had forgone the GPL therefore weren't protected by it...

Not sure how well that would fly, but I think it would stand a good chance.

Cheers,
Wol

GCC 10.1 Released

flussence — Sat, 18 Jul 2020 10:58:31 +0000

Quoth the GPL:

> For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

OpenWRT is a whole OS-building SDK unto itself: a cross-compiler is bundled with it, is not a typical component found in a host OS, and cannot be trivially replaced (not least due to the fact that it's a heavily patched copy of GCC).

GCC 10.1 Released

immibis — Mon, 13 Jul 2020 13:04:10 +0000

Why would they need to give you the compiler?

GCC 10.1 Released

mathstuf — Fri, 15 May 2020 21:04:11 +0000

> they actually open sourced their gcc-based Objective-C compiler in 90-s

Wasn't that under threat of lawsuit though? I wouldn't call that willful compliance.

GCC 10.1 Released

Cyberax — Fri, 15 May 2020 20:58:49 +0000

> I woundt say "no problems". More like it was mostly bearable and 3 was unbearable enough to warrant rewriting.
Well, it's a different way of saying it. But Apple really was OK with GPLv2, they actually open sourced their gcc-based Objective-C compiler in 90-s. I think it was esr who convinced them to do that?

> I wouldn't put much stock in their opinions of the GPL.
The problem is, Apple is not unique in their approach to GPLv3. It's explicitly banned in all large companies that I've worked in so far.

GCC 10.1 Released

mathstuf — Fri, 15 May 2020 20:28:15 +0000

I woundt say "no problems". More like it was mostly bearable and 3 was unbearable enough to warrant rewriting. Either way, with how generally hostile Apple is to free software and developers anyways, I wouldn't put much stock in their opinions of the GPL.

GCC 10.1 Released

songmaster — Fri, 15 May 2020 02:59:26 +0000

> software patents have pretty much been killed by SCOTUS now.

Sadly that doesn’t seem to have happened, the US patent office wrote some guidance for its examiners that effectively contradicted the SCOTUS Alice ruling and it’s now back to giving out stupid patents again. See this Techdirt article [1] for more details.

[1] https://www.techdirt.com/articles/20200423/15295144360/us...

GCC 10.1 Released

Wol — Wed, 13 May 2020 15:41:06 +0000

> and in particular didn't have any language wrt patents.

OMG NO!!!

That is my beef with the GPL3 - patent language does not belong in a copyright licence!!! By all means stick a defensive clause in, but hopefully actually it's all moot now. I don't know the latest state of play, but I think software patents have pretty much been killed by SCOTUS now.

> wasn't really anything to do with copyleft vs permissive, but rather that the license itself was unclear

and the defendant thought he could assume, BECAUSE the language was unclear, that the stuff was actually in the public domain. If you read the wiki article, it sounds like that's what he persuaded the court first time around, but the appeal court knocked that on the head. "If the conditions are unclear, it doesn't mean there are no conditions. It means the copyright holder has gone to the trouble of setting conditions and you must assume you need a licence".

Cheers,
Wol

GCC 10.1 Released

joib — Wed, 13 May 2020 09:32:07 +0000

I remember reading about the JMRI case here on lwn back when it happened. But IIRC the issue with the Artistic license JMRI used wasn't really anything to do with copyleft vs permissive, but rather that the license itself was unclear, and in particular didn't have any language wrt patents.

There exists both copyleft and permissive licenses that don't suffer from these problems.

GCC 10.1 Released

ballombe — Tue, 12 May 2020 22:28:05 +0000

Jeremy do not mention the reverse case where the FOSS developer is sued. In that case the GNU GPL can give you counterclaims,
see the JMRI case <https://en.wikipedia.org/wiki/Jacobsen_v._Katzer>

GCC 10.1 Released

Cyberax — Mon, 11 May 2020 16:00:46 +0000

Apple used LLVM for other purposes (famously for PDF rendering and OpenGL in the UI engine), so it's no wonder they were hiring LLVM developers. However, the work on clang started immediately after the first GPLv3 drafts were made public.

And it's absolutely GPLv3. Apple has no problems shipping GPLv2, but they went as far as rewriting SMB implementation to avoid shipping Samba 3.

GCC 10.1 Released

mathstuf — Mon, 11 May 2020 14:38:00 +0000

> Aside: This is poor practice. You should serve a basic HTML page that works in any reasonable* browser, and then use JavaScript to progressively enable functionality that the current browser actually supports.

I was more thinking about deciding to use whatever experimental HTTP headers browsers support these days more than serving up different code based on the user agent.

Probably should have said "HTTP servers are" rather than "server-side-only is".

GCC 10.1 Released

anton — Mon, 11 May 2020 11:42:17 +0000

Chris Lattner had already been hired by Apple in February 2005. The first GPL v3 draft was published in January 2006, with the announcement of the work on GPL v3 in late 2005.

Apple did not want to comply with GPL v2 when they built the Objective-C front end for gcc (but eventually complied). Not really a sign that they are fine with GPLv2.

GCC 10.1 Released

oldtomas — Mon, 11 May 2020 09:14:17 +0000

So there's still hope?

I was under the impression that only a disruptive (possibly "external") event could derail this horror train. It just meshes too well with surveillance capitalism (and even worse "surveillance" things, with some perverse common interests).

So thanks for shining some light of hope into an otherwise gray day :-)

GCC 10.1 Released

joib — Mon, 11 May 2020 07:00:37 +0000

See also Jeremy Allison's presentation from the copyleft 2020 conference: https://lwn.net/Articles/818979/

Considering jra was one of the authors of the GPLv3, and has relicensed some significant software to GPLv3, he being disillusioned with it, and with copyleft enforcement in general, might tell something.

If, for the sake of argument, we take jra's arguments at face value, what are the implications? I suggest something like

- Might as well choose a permissive license, to get the largest possible user base. That is, instead of viewing FOSS as a commons (see Ostrom), view it as a public good.

- The four freedoms are as important as before, if not more. But if not copyleft enforcement, how to achieve it? a) jra's "documented and interoperable protocols" suggestion 2) Right to repair legislation? 3) Address the power imbalance between the citizens and internet giants (social media, cloud providers); Maybe view them as utilities subject to legislation like telecom and electricity?

- Implement federated/distributed architectures that respect user freedom and privacy, and circumvent the scale advantages of the internet giants. So far things like FreedomBox and Mastodon haven't really been killer apps, but maybe there's something out there to be discovered?

I have to admit this feels uncomfortable, as it relies to a large extent on "traditional" political activism. Which is uncomfortable for a nerd; we'd rather just write code and pretend that slapping on a copyleft license takes care of the political part.

GCC 10.1 Released

flussence — Mon, 11 May 2020 06:38:18 +0000

The pendulum is now swinging back the other way, servers and browsers can negotiate supported features using only HTTP headers: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers...

There seems to be a gradual movement in web development back to inert content, following a collective realisation that doing everything in Javascript is a horrendous idea for performance, security and durability.

GCC 10.1 Released

flussence — Mon, 11 May 2020 06:17:46 +0000

The GPL — which derives its clout from copyright law — only protects the author, and then only those that can afford legal action against copyright infringers. If an end user finds they're getting shafted by a company peddling routers/TVs/ARM SoCs, they can't do anything besides report it back to the copyright holder and hope action is taken.

GCC 10.1 Released

pabs — Mon, 11 May 2020 04:54:52 +0000

If the router runs OpenWRT (and thus Linux) then it seems like you should be able to get the compiler and its sources.

GCC 10.1 Released

NYKevin — Mon, 11 May 2020 02:35:35 +0000

> (server-side-only is still stuck with user agent AFAIK)

Aside: This is poor practice. You should serve a basic HTML page that works in any reasonable* browser, and then use JavaScript to progressively enable functionality that the current browser actually supports. That JavaScript should call into the server (if necessary) and pass information about the client (if necessary). At no point should the server be in a position of trying to guess a browser's capabilities based on HTTP headers alone, unless the client is not a browser and therefore not capable of executing JavaScript (at which point you are well off the beaten track and "best practices" are no longer a thing).

This does mean that users with JavaScript disabled will get a less functional website than would otherwise be possible to provide (for example, it might lack modern CSS functionality and look uglier than strictly necessary). But those differences should be mostly presentational, and should not interfere with the core functionality of the website (unless you hate your users).

* For whatever definition of "reasonable" your market research has led you to use. In practice, this is usually "Chrome plus some other ones," but whether that list includes IE, Opera, etc. may vary. A corporate intranet site has very different needs from google.com.

GCC 10.1 Released

mathstuf — Sun, 10 May 2020 21:43:59 +0000

Except now, there is something called "JavaScript" which has access to real functionality and feature detection that you can do (server-side-only is still stuck with user agent AFAIK) provided the standards bodies bother providing such things. C and C++ only recently got more rigorous about adding things you can use to detect features like `__has_feature`, `__has_include`, and the myriad of feature test macros that now exist (though with C++20 modules, `__has_module` is an unaskable question due to the typical C++ compilation model). Unfortunately, the effective EOL horizon for compilers is much further away than the EOL horizon for browsers, so you *still* need all those old hacks (we have GCC 4.8 on target machines still :( ). Plus, that's only the stdlib. POSIX conformance bugs and kernel capabilities are still without consistent preprocessor detection and you're stuck with slow and wasteful configure checks.

GCC 10.1 Released

NYKevin — Sun, 10 May 2020 20:12:39 +0000

So it's the UserAgent string all over again... and GCC is Mozilla/5.0.

GCC 10.1 Released

mathstuf — Sun, 10 May 2020 13:46:05 +0000

> Apparently Apple uses a time machine to fetch their branch

No, this is because you have Xcode 11. Apple builds the Xcode toolchain off an internal branch of the repository and has a completely different versioning scheme (cf. the difference between the Clang and AppleClang compiler ids in CMake).

GCC 10.1 Released

mathstuf — Sun, 10 May 2020 13:44:30 +0000

This is because so many C and C++ projects do compiler detection at some level. When building a new compiler, it is easiest to claim to be some other compiler to avoid falling into a myriad of "#error unknown compiler!" holes. Everyone claims GCC since it is prevalent and widely supported anyways. Nowadays, there are lots of frontends based on Clang, so __clang__ is in the same situation today.

When detecting compilers, this is generally the detection order I'd suggest:

- nvcc (because *sigh*)
- platform toolchains (xlc, acc, etc.)
- vendor toolchains (icc, msvc, etc.)
- clang
- gcc
- #error unknown (or #warning and assume GCC-alike)

It is for this reason as well that GCC can't add a "I'm really GCC!" definition: other compilers would end up having to emulate *that* definition as well to get off the ground.

GCC 10.1 Released

mpr22 — Sun, 10 May 2020 13:24:21 +0000

The GPL only protects people if they actually receive the covered software.

If your router arrives without the compiler, then you have no standing to demand a copy of the source code for the compiler.

GCC 10.1 Released

Conan_Kudo — Sun, 10 May 2020 13:09:59 +0000

This was probably the most painful GCC update that I've participated in a while. Almost all of my development time for Fedora 32 was spent fixing broken builds caused by this change in GCC. Not that I think it was a bad change, but I did not expect how much breakage it caused...

GCC 10.1 Released

zoobab — Sun, 10 May 2020 12:33:55 +0000

"Let's be honest: Apple wanted clang to be a non-GPL gcc replacement."

We are under the threat of a permissive license, which imply, for example, no obligation to release the source code of custom patches, which is pretty common in the embedded world.

This will lead to the refusal from routers manufacturers (like the routers where you can run OpenWRT) to release the sources of their compiler.

GCC 10.1 Released

ballombe — Sun, 10 May 2020 09:16:36 +0000

Apparently Apple ethos require then to ship XCode with a broken C compiler.
For a long time they shipped broken version of gcc, and now they ship broken version of clang.
I though that clang was a pile of cruft until I tried the Debian build and then suddenly it was
almost on par with gcc.

GCC 10.1 Released

felix.s — Sun, 10 May 2020 08:20:06 +0000

Are you referring to the fact that __has_builtin returns 0 for those built-ins that are not functions, but keywords? Because that’s hardly ‘unusable’, especially that keywords can be tested for via !__is_identifier.

GCC 10.1 Released

ndesaulniers — Sun, 10 May 2020 05:44:08 +0000

> broken (or at least unusable) prior to clang 10.

How's that?

GCC 10.1 Released

RedDwarf — Sat, 09 May 2020 19:16:57 +0000

Yes. When I read it I though "OK, if I see any variable defined in a header I will need to put it in a source file, whatever". Then I don't remember what I was building and I found what I guess (at the end I didn't end up building it, didn't check in detail) was somebody forgetting to use static when defining a couple of file-scope variables with the same name... but it made me understand how horrible the "-fcommon" default was.

Was that variable supposed to be shared by those two files or not?
Even if it was not intended to be shared, maybe the program is only working by accident and is going to break if I add the "static"s?

I can't even imagine how much fun the Fedora packagers must have had with Fedora 32. I guess more than one must have started to simply add "-fcommon" to his packages CFLAGS out of desperation.

GCC 10.1 Released

dtlin — Sat, 09 May 2020 03:06:41 +0000

https://pubs.opengroup.org/onlinepubs/9699919799/utilitie...

Some options are specified.

GCC 10.1 Released

rahulsundaram — Sat, 09 May 2020 01:14:04 +0000

I wrote the page originally but haven't updated that in years. Just did some minor tweaks now. It could definitely use a more comprehensive revamp. It is a wiki page so anyone interested, have at it.

GCC 10.1 Released

josh — Sat, 09 May 2020 00:35:41 +0000

"contributor" would be accurate, but "lead maintainer" no longer is.

GCC 10.1 Released

wahern — Fri, 08 May 2020 23:53:02 +0000

It reports itself as 4.2.1. clang was designed to be compatible with GCC 4.2.1, with the notable exception of nested functions, and maybe a few other esoteric features. Intel C++ started defining __GNUC__, et al long before clang existed, so in practice __GNUC__ hasn't implied GCC for a long-time.

What's more annoying is how Apple's build of clang reports itself. Apparently Apple uses a time machine to fetch their branch:

% cc -dM -E - < /dev/null | grep clang
#define __VERSION__ "4.2.1 Compatible Apple LLVM 11.0.0 (clang-1100.0.33.17)"
#define __clang__ 1
#define __clang_major__ 11
#define __clang_minor__ 0
#define __clang_patchlevel__ 0
#define __clang_version__ "11.0.0 (clang-1100.0.33.17)"

clang 11 hasn't been released. In fact, clang 10 was just released about a month ago. Although, if you just accept that clang is effectively Apple's project--that Apple has veto power over anything they dislike, much like the FSF and Stallman with GCC--and not a completely independent open source project, then it's less objectionable, although no less confusing.

clang did introduce useful feature test macros like __has_attribute, __has_extension, etc, which permit direct feature detection. But the most useful test macro, __has_builtin, is relatively recent--adopted by GCC 9, and broken (or at least unusable) prior to clang 10.

GCC 10.1 Released

madscientist — Fri, 08 May 2020 23:23:45 +0000

That's because so many of the system headers in glibc, etc. have special capabilities if you're using GCC. Since clang also supports those capabilities, it defines those macros as well.

However, you _can_ tell the difference between the two compilers if you need to... one way is that GCC doesn't define any of the clang predefined macros like __clang__ etc.

GCC 10.1 Released

sorpigal — Fri, 08 May 2020 23:03:55 +0000

I'm not surprised that C doesn't specify any CLI standard, just that POSIX doesn't. Some standard ought to, I think.

GCC 10.1 Released

atai — Fri, 08 May 2020 23:00:13 +0000

lor clang even defines gcc's macro for compiler identification, kind of defeating the purpose of id'ing the compiler

GCC 10.1 Released

madscientist — Fri, 08 May 2020 20:46:01 +0000

clang does take this too far in places unfortunately.

One example: both GCC and clang support precompiled headers. However the format of the PCH files is very different, so that clang can't read GCC's file and vice versa. That's perfectly reasonable, and GCC creates PCH files suffixed with .gch and clang suffixes its PCH files with .pch.

What's not so great is that clang ALSO tries to read files using GCC's extension .gch, and then fails (with a somewhat cryptic message) if it can't parse it (because it's a real GCC PCH file).

This is a serious problem if you're trying to use both GCC and clang at the same time (for example, maybe you're using clangd for code inspection or similar but still build code with GCC).

In this case the attempt to make it easy to switch from GCC to clang, by reusing the GCC filename, is certainly causing problems.

GCC 10.1 Released

ballombe — Fri, 08 May 2020 20:33:38 +0000

Of course. gcc implements an extension of the standard options of POSIX cc.
This explain some awkwardness like -Wl, etc.
See <https://pubs.opengroup.org/onlinepubs/7908799/xcu/cc.html>