Re: DragonEgg has been revived

["Dan'l Miller" <optikos@verizon.net>]

[fixed typos]
On Wednesday, May 23, 2018 at 2:26:49 AM UTC-5, Simon Wright wrote: 
> Simon Clubley <clubley@remove_me.eisner.decus.org-Earth.UFP> writes: 
> 
> > What I would like to see is an Ada compiler that can generate code for 
> > a wide range of targets without any GPL restrictions on the generated 
> > code. 
> 
> Pretty sure that's called GCC. 

Pretty sure that you haven't read the Object Code clauses in GPLv3 and the Target Code clauses and Eligible Compilation Process clauses in the Runtime Exception v3.1.  GPL restrictions galore on the generated code there in Target Code & Eligible Compilation Process (in Runtime Exception v3.1) interacting with Object Code, where Object Code is •everything• not Source Code (in GPLv3).  IR would therefore be Object Code due to being not Target Code and not Source Code.

Just because IR-based technologies haven't historically been utilized widely yet in the enterprise (and thus receive the attention of Sarbanes-Oxley internal-controls compliance in the finance department and contract compliance in the legal department), doesn't mean that technologies in the ballpark of McSema (resurrect IR from hardware-processor machine code) and GraalVM (mix LLVM IR with JVM bytecode to produce hardware-processor machine-code via Polyglot) will not be utilized by the enterprise tomorrow. 

> People 

historically  (There, fixed that for you; tomorrow's IR-IR-everywhere-for-world-plus-dog is a new era.) 

> are perfectly happy to use GCC for C-based commercial projects in 
> spite of the fact that libgcc, and GNU libstdc++, if you're that way 
> inclined, have *exactly* the same runtime exception as FSF GNAT's RTS 
> and the GNAT Pro RTS. 
> 
> The formal position is that the GCC compiler itself doesn't assert any 
> licensing restrictions over target code generated by it beyond that 
> derived from the original source code. 

You are so GPLv2; that is the way it was under GPLv2 back in the old days.  Newsflash: nearly a decade ago, they relicensed modern releases of FSF GCC as GPLv3 with Runtime Exception v3.1 which does in fact have licensing restrictions on Target Code and on Eligible Compilation Process (via Runtime Exception v3.1) by merely passing, say, MIT/X11-licensed or BSD-licensed source code through the modern GCC compiler to generate the Target Code for that MIT/X11-licensed or BSD-licensed executable or DLL.  Simon, you are •factually incorrect• nowadays (post-GPLv2) in your claim “that the GCC compiler itself doesn't assert any licensing restrictions over target code generated by it beyond that derived from the original source code”, because the ••GPLv3 license of the modern GCC compiler itself•• spreads (dare I say, virally) to the otherwise MIT/X11-licensed or BSD-licensed Target Code 

1) if that Target-Code hardware-processor's machine-code is lifted by, say, McSema back to LLVM bitcode IR 
or 

2) if somehow a GCC-written IR derived from that MIT/X11-licensed or BSD-licensed source code and then fed into, say, LLVM and/or Polly and/or GraalVM stand-alone* executable(s) which then itself produces the hardware-processor machine-code 
or 

* i.e., as they are packaged today as executables that are invoked downstream (long) after modern GCC's executable finished executing 

3) #1 & #2 above are just the first 2 examples of emerging technology in the IR domain and in the rework-the-machine-code domain. 
3.1) For example, imagine an anti-malware add-on (that, for the sake of discussion here, violates the Target Code or Eligible Compilation Process clauses of a modern-GCC-written executable or DLL) to operating systems that reworks the machine-code at link-load time to eliminate: 
3.1.1) buffer-overrun injection of worms; and/or 
3.1.2) removes viruses/etc-malware that have attached themselves to the executable or DLL and/or 
3.1.3) randomizes the layout of the machine code each link-loader-time so that malware cannot easily recognize that executable or DLL. 

4) Indeed, viruses that modify a modern-GCC-written Target Code to insert the virus into machine code could quite easily violate either the Target Code clause of GPLv3 or the Eligible Compilation Process clause of the Runtime Exception or both (unless the virus fully complied with the entirety of GPLv3, including providing its source code to those people to whom the virus was distributed/infected). 

Please note that each of #1, #2, #3.1, and #4 are all performed by a party other than the original developer of the MIT/X11-licensed source code.  Note especially that each of #1, #3.1, and #4 can clearly all be performed by a party other than the person who invoked the GCC compiler to write out that executable or DLL file.  (Only #2 seems to need an overt extra act at the time of GCC-compilation.) 

On the surface (conceivably shockingly preposterously), merely running a closed-source permissive-licensed modern-GCC-compiled executable or DLL through, say, McSema can allow the downstream 3rd-party person who lifted the GCC-compiled machine code to that LLVM bitcode IR to then demand the source code (!) to that otherwise closed-source (!) permissively-licensed executable o DLL, because not only is the IR GPLv3-licensed, but, more bizarrely more importantly, the GCC-compiled hardware-processor machine-code executable or DLL is retroactively (!) GPLv3-licensed (!) under the Target Code and/or Eligible Compilation Process clauses' overt retroactive revocation of rights on the machine code that was generated by modern GCC.  This seems preposterous, but merely mechanically turning the crank of the Target Code & Eligible Compilation Process language in GPLv3 & its Runtime Exception seems to quite directly say this (at least to me under my plain-language reading of the terms of the license contract, as I am permitted to do for myself under Texas contract law). 

disclaimer: 
[I am not a lawyer who has passed the bar in any jurisdiction whatsoever.  Do not rely on any of this for any purpose.  Seek the counsel of an attorney duly certified for the system of law within the jurisdiction(s) in which you reside or operate.] 

Pretty sure all this above are examples of where Shark8 would use the term “all the morass of licensing surrounding” GPLv3-with-Runtime-Exception-v3.1-licensed modern GCC. 

> I can see that people, especially commercial lawyers, might be confused 
> about this, especially if they read 

the Target Code clauses or Eligible Compilation Process clauses of the Runtime Exception v3.1 (There, fixed that for you; that is what they need to read.) 

> all the hot air that's been blasting over this newsgroup lately. 

Yeah right.  Encouraging people to actually read the Target Code and Eligible Compilation Process clauses of the Runtime Exception v3.1 and revealing why it is important that they do so is dismissed as “hot air … blasting”.