* In GCC 10.2, -O2 optimization enables more than docs suggest
@ 2021-01-16 20:48 Brent Roman
2021-01-20 15:56 ` Richard Earnshaw
0 siblings, 1 reply; 10+ messages in thread
From: Brent Roman @ 2021-01-16 20:48 UTC (permalink / raw)
To: gcc-help
My very old, highly modified Matz Ruby 1.87 interpreter stopped working
when Debian switched from GCC-9 to GCC-10
The Ruby interpreter binary output from GCC-10 segfaults.
However, if I reduce optimization from -O2 to -O1, the resulting
binaries work fine.
I'd like to find which specific -O2 optimization is causing the failure
when run through gcc-10.
But, when I specified -O1 followed by options explicitly enabling all
the specific optimizations that are supposed to be enabled by -O2,
the resulting binary works fine. Conversely, when I specify -O2,
followed by explicit options to *disable* all those options, the
resulting binary fails.
Does anyone know what -O2 enables aside from the options documented on:
https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Optimize-Options.html#Optimize-Options
Here's an example of a gcc invocation with -O2 followed by disabling all
the -O2 specific optimizations:
gcc -O2 -g -Wclobbered -fno-stack-protector -fno-align-functions
-fno-align-jumps -fno-align-labels -fno-align-loops -fno-caller-saves
-fno-code-hoisting -fno-crossjumping -fno-cse-follow-jumps
-fno-cse-skip-blocks -fno-delete-null-pointer-checks -fno-devirtualize
-fno-devirtualize-speculatively -fno-expensive-optimizations
-fno-finite-loops -fno-gcse -fno-gcse-lm -fno-hoist-adjacent-loads
-fno-inline-functions -fno-inline-small-functions
-fno-indirect-inlining -fno-ipa-bit-cp -fno-ipa-cp -fno-ipa-icf
-fno-ipa-ra -fno-ipa-sra -fno-ipa-vrp
-fno-isolate-erroneous-paths-dereference -fno-lra-remat
-fno-optimize-sibling-calls -fno-optimize-strlen -fno-partial-inlining
-fno-peephole2 -fno-reorder-blocks-and-partition -fno-reorder-functions
-fno-rerun-cse-after-loop -fno-schedule-insns -fno-schedule-insns2
-fno-sched-interblock -fno-sched-spec -fno-store-merging
-fno-strict-aliasing -fno-thread-jumps -fno-tree-builtin-call-dce
-fno-tree-pre -fno-tree-switch-conversion -fno-tree-tail-merge
-fno-tree-vrp -DRUBY_EXPORT -D_GNU_SOURCE=1 -I. -I. -c main.c
Thanks!
--
Brent Roman MBARI
Software Engineer Tel: (831) 775-1808
mailto:brent@mbari.org http://www.mbari.org/~brent
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-16 20:48 In GCC 10.2, -O2 optimization enables more than docs suggest Brent Roman
@ 2021-01-20 15:56 ` Richard Earnshaw
2021-01-20 16:53 ` mark_at_yahoo
0 siblings, 1 reply; 10+ messages in thread
From: Richard Earnshaw @ 2021-01-20 15:56 UTC (permalink / raw)
To: Brent Roman, gcc-help
On 16/01/2021 20:48, Brent Roman wrote:
> My very old, highly modified Matz Ruby 1.87 interpreter stopped working
> when Debian switched from GCC-9 to GCC-10
>
> The Ruby interpreter binary output from GCC-10 segfaults.
>
> However, if I reduce optimization from -O2 to -O1, the resulting
> binaries work fine.
>
> I'd like to find which specific -O2 optimization is causing the failure
> when run through gcc-10.
>
> But, when I specified -O1 followed by options explicitly enabling all
> the specific optimizations that are supposed to be enabled by -O2,
> the resulting binary works fine. Conversely, when I specify -O2,
> followed by explicit options to *disable* all those options, the
> resulting binary fails.
>
> Does anyone know what -O2 enables aside from the options documented on:
>
> https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Optimize-Options.html#Optimize-Options
>
>
> Here's an example of a gcc invocation with -O2 followed by disabling all
> the -O2 specific optimizations:
>
> gcc -O2 -g -Wclobbered -fno-stack-protector -fno-align-functions
> -fno-align-jumps -fno-align-labels -fno-align-loops -fno-caller-saves
> -fno-code-hoisting -fno-crossjumping -fno-cse-follow-jumps
> -fno-cse-skip-blocks -fno-delete-null-pointer-checks -fno-devirtualize
> -fno-devirtualize-speculatively -fno-expensive-optimizations
> -fno-finite-loops -fno-gcse -fno-gcse-lm -fno-hoist-adjacent-loads
> -fno-inline-functions -fno-inline-small-functions
> -fno-indirect-inlining -fno-ipa-bit-cp -fno-ipa-cp -fno-ipa-icf
> -fno-ipa-ra -fno-ipa-sra -fno-ipa-vrp
> -fno-isolate-erroneous-paths-dereference -fno-lra-remat
> -fno-optimize-sibling-calls -fno-optimize-strlen -fno-partial-inlining
> -fno-peephole2 -fno-reorder-blocks-and-partition -fno-reorder-functions
> -fno-rerun-cse-after-loop -fno-schedule-insns -fno-schedule-insns2
> -fno-sched-interblock -fno-sched-spec -fno-store-merging
> -fno-strict-aliasing -fno-thread-jumps -fno-tree-builtin-call-dce
> -fno-tree-pre -fno-tree-switch-conversion -fno-tree-tail-merge
> -fno-tree-vrp -DRUBY_EXPORT -D_GNU_SOURCE=1 -I. -I. -c main.c
>
>
> Thanks!
>
>
Sorry, it's not as simple as that. There are places in the compiler
where the optimization level (O1, O2, O3) is just tested with something like
if (optimize >= level)
for some level.
R.
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 15:56 ` Richard Earnshaw
@ 2021-01-20 16:53 ` mark_at_yahoo
2021-01-20 18:50 ` Jonathan Wakely
2021-01-20 21:17 ` David Brown
0 siblings, 2 replies; 10+ messages in thread
From: mark_at_yahoo @ 2021-01-20 16:53 UTC (permalink / raw)
To: gcc-help
On 1/20/21 7:56 AM, Richard Earnshaw via Gcc-help wrote:
> On 16/01/2021 20:48, Brent Roman wrote:
>> Here's an example of a gcc invocation with -O2 followed by disabling all
>> the -O2 specific optimizations:
>> ...
>
> Sorry, it's not as simple as that. There are places in the compiler
> where the optimization level (O1, O2, O3) is just tested with something like
>
> if (optimize >= level)
>
> for some level.
>
> R.
>
Just chiming in with an opinion here. I've had the same problem and came
to the same conclusion ("-f" options do not fully replace/override "-O")
although I didn't know the compiler source was that explicit about it
(thanks for the info).
I realize this is very unlikely to change but find the situation
unfortunate. My use-case is with the GNU Arm Embedded Toolchain port of
GCC and my https://github.com/thanks4opensource/regbits development
system. The latter creates C++ header files with literally thousands of
constexpr objects of which only a handful are used in a typical program.
If compiled O1 or above, the linker only allocates storage for the
objects that are used. At O0 it allocates all of them which makes the
resulting binary far too large to fit in a typical embedded processor's
memory space. But O0 is very useful for assembly-level debugging in GDB
(often required in embedded development) because the generated code is
much simpler and easier to correlate with the original C++ source.
I've only had limited success coming up with a set of -f options to add
to O0 to eliminate the unused objects but retain the un-optimized binary
code. The above explains why, but it would be nice if the -O options
really were just a set of -f ones and users could customize to their
needs. Without implementing my specific "-O0.5" option. ;)
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 16:53 ` mark_at_yahoo
@ 2021-01-20 18:50 ` Jonathan Wakely
2021-01-20 19:06 ` mark_at_yahoo
2021-01-20 21:17 ` David Brown
1 sibling, 1 reply; 10+ messages in thread
From: Jonathan Wakely @ 2021-01-20 18:50 UTC (permalink / raw)
To: mark_at_yahoo; +Cc: gcc-help
On Wed, 20 Jan 2021, 16:54 mark_at_yahoo via Gcc-help, <gcc-help@gcc.gnu.org>
wrote:
> On 1/20/21 7:56 AM, Richard Earnshaw via Gcc-help wrote:
> > On 16/01/2021 20:48, Brent Roman wrote:
> >> Here's an example of a gcc invocation with -O2 followed by disabling all
> >> the -O2 specific optimizations:
> >> ...
> >
> > Sorry, it's not as simple as that. There are places in the compiler
> > where the optimization level (O1, O2, O3) is just tested with something
> like
> >
> > if (optimize >= level)
> >
> > for some level.
> >
> > R.
> >
>
> Just chiming in with an opinion here. I've had the same problem and came
> to the same conclusion ("-f" options do not fully replace/override "-O")
> although I didn't know the compiler source was that explicit about it
> (thanks for the info).
>
> I realize this is very unlikely to change but find the situation
> unfortunate. My use-case is with the GNU Arm Embedded Toolchain port of
> GCC and my https://github.com/thanks4opensource/regbits development
> system. The latter creates C++ header files with literally thousands of
> constexpr objects of which only a handful are used in a typical program.
> If compiled O1 or above, the linker only allocates storage for the
> objects that are used. At O0 it allocates all of them which makes the
> resulting binary far too large to fit in a typical embedded processor's
> memory space. But O0 is very useful for assembly-level debugging in GDB
> (often required in embedded development) because the generated code is
> much simpler and easier to correlate with the original C++ source.
>
> I've only had limited success coming up with a set of -f options to add
> to O0 to eliminate the unused objects but retain the un-optimized binary
> code.
That's a different situation though. With -O0 **NO** optimization is done,
at all. Any -f options for optimization passes are ignored entirely.
The difference between -O1 and -O2 is the set of -f flags that differ, and
some specific checks for >= -O2. But the difference between -O0 and -O1 is
the difference between zero and non-zero. Completely off, or on.
The above explains why, but it would be nice if the -O options
> really were just a set of -f ones and users could customize to their
> needs. Without implementing my specific "-O0.5" option. ;)
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 18:50 ` Jonathan Wakely
@ 2021-01-20 19:06 ` mark_at_yahoo
2021-01-20 19:44 ` Jonathan Wakely
0 siblings, 1 reply; 10+ messages in thread
From: mark_at_yahoo @ 2021-01-20 19:06 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc-help
On 1/20/21 10:50 AM, Jonathan Wakely wrote:
> That's a different situation though. With -O0 **NO** optimization is done,
> at all. Any -f options for optimization passes are ignored entirely.
>
> The difference between -O1 and -O2 is the set of -f flags that differ, and
> some specific checks for >= -O2. But the difference between -O0 and -O1 is
> the difference between zero and non-zero. Completely off, or on.
>
That's interesting, Jonathan. You know far better than I do, and I
haven't tried it in over a year (on an older version of GCC-ARM), but I
swore the following did do something:
OPTIMIZE_FLAG := -O0 \
-fbranch-count-reg \
-fcombine-stack-adjustments \
-fcompare-elim \
-fcprop-registers \
-fdefer-pop \
-fforward-propagate \
-fguess-branch-probability \
-fif-conversion \
-fif-conversion2 \
-finline \
-finline-functions-called-once \
-fipa-profile \
-fipa-pure-const \
-fipa-reference \
-fmerge-constants \
-fmove-loop-invariants \
-fomit-frame-pointer \
-freorder-blocks \
-fsched-pressure \
-fsection-anchors \
-fshrink-wrap \
-fsplit-wide-types \
-fssa-phiopt \
-ftoplevel-reorder \
-ftree-bit-ccp \
-ftree-builtin-call-dce \
-ftree-ccp \
-ftree-ch \
-ftree-coalesce-vars \
-ftree-copy-prop \
-ftree-dce \
-ftree-dominator-opts \
-ftree-dse \
-ftree-fre \
-ftree-pta \
-ftree-sink \
-ftree-slsr \
-ftree-sra \
-ftree-ter \
-fvar-tracking \
-fvar-tracking-assignments
Maybe because you said "optimization passes"? The ones above (or some of
them) are for other passes?
--
MARK
markrubn@yahoo.com
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 19:06 ` mark_at_yahoo
@ 2021-01-20 19:44 ` Jonathan Wakely
2021-01-20 20:45 ` mark_at_yahoo
0 siblings, 1 reply; 10+ messages in thread
From: Jonathan Wakely @ 2021-01-20 19:44 UTC (permalink / raw)
To: mark_at_yahoo; +Cc: gcc-help
On Wed, 20 Jan 2021 at 19:06, mark_at_yahoo <markrubn@yahoo.com> wrote:
>
> On 1/20/21 10:50 AM, Jonathan Wakely wrote:
>
> > That's a different situation though. With -O0 **NO** optimization is done,
> > at all. Any -f options for optimization passes are ignored entirely.
> >
> > The difference between -O1 and -O2 is the set of -f flags that differ, and
> > some specific checks for >= -O2. But the difference between -O0 and -O1 is
> > the difference between zero and non-zero. Completely off, or on.
> >
>
> That's interesting, Jonathan. You know far better than I do, and I
> haven't tried it in over a year (on an older version of GCC-ARM), but I
> swore the following did do something:
It might have done something, but it didn't optimize anything (and so
most of those options were ignored).
https://gcc.gnu.org/wiki/FAQ#optimization-options
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 19:44 ` Jonathan Wakely
@ 2021-01-20 20:45 ` mark_at_yahoo
0 siblings, 0 replies; 10+ messages in thread
From: mark_at_yahoo @ 2021-01-20 20:45 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc-help
On 1/20/21 11:44 AM, Jonathan Wakely wrote:
> It might have done something, but it didn't optimize anything (and so
> most of those options were ignored).
Apologies for beating a dead horse, and I'll bow out after this, but
when I said "did something" I meant that it solved my problem of wanting
an un-optimized binary as per O0 but without instantiation and memory
allocation of unused constexpr objects as per O1 and above. Whether
that's an optimization or not seems a matter of semantics.
> https://gcc.gnu.org/wiki/FAQ#optimization-options
Yes, --help=optimizers with -O1 and adding various permutations of the
ones it output is what I did. You've strongly implied that this
shouldn't work (assuming the constexpr elimination is done in an
optimization pass) so at some point I'll revisit the issue with a
current GCC version and report if I find something interesting.
There were some issues with my "O0 plus -f options" so I eventually
learned to "bite the bullet" and debug optimized/obfuscated (and that's
a good thing) O1 assembly output and didn't work on it further.
--
MARK
markrubn@yahoo.com
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 16:53 ` mark_at_yahoo
2021-01-20 18:50 ` Jonathan Wakely
@ 2021-01-20 21:17 ` David Brown
2021-01-21 3:53 ` mark_at_yahoo
1 sibling, 1 reply; 10+ messages in thread
From: David Brown @ 2021-01-20 21:17 UTC (permalink / raw)
To: mark_at_yahoo, gcc-help
On 20/01/2021 17:53, mark_at_yahoo via Gcc-help wrote:
> On 1/20/21 7:56 AM, Richard Earnshaw via Gcc-help wrote:
>> On 16/01/2021 20:48, Brent Roman wrote:
>>> Here's an example of a gcc invocation with -O2 followed by disabling all
>>> the -O2 specific optimizations:
>>> ...
>>
>> Sorry, it's not as simple as that. There are places in the compiler
>> where the optimization level (O1, O2, O3) is just tested with
>> something like
>>
>> if (optimize >= level)
>>
>> for some level.
>>
>> R.
>>
>
> Just chiming in with an opinion here. I've had the same problem and came
> to the same conclusion ("-f" options do not fully replace/override "-O")
> although I didn't know the compiler source was that explicit about it
> (thanks for the info).
>
> I realize this is very unlikely to change but find the situation
> unfortunate. My use-case is with the GNU Arm Embedded Toolchain port of
> GCC and my https://github.com/thanks4opensource/regbits development
> system. The latter creates C++ header files with literally thousands of
> constexpr objects of which only a handful are used in a typical program.
> If compiled O1 or above, the linker only allocates storage for the
> objects that are used. At O0 it allocates all of them which makes the
> resulting binary far too large to fit in a typical embedded processor's
> memory space. But O0 is very useful for assembly-level debugging in GDB
> (often required in embedded development) because the generated code is
> much simpler and easier to correlate with the original C++ source.
>
I also work on embedded systems (usually with the ARM gcc toolchain
these days, but at times I use many others).
I /never/ use -O0, precisely because I find it absolutely terrible for
assembly level debugging. You can't see the wood for the trees, as all
local variables are on the stack, and even the simplest of C expressions
ends up with large numbers of assembly instructions. In my experience -
and this is obviously very subjective - using -O1 gives far more
readable assembly code while avoiding the kinds of code re-arrangement
and re-ordering of -O2 that makes assembly-level debugging difficult.
(-Og is an alternative for modern gcc versions, which can give most of
the speed of -O2 but is a little easier for debugging).
Another major benefit of -O1 is that it enables much more code analysis,
which in turn enables much better static checking - I am a big fan of
warning flags and having the compiler tell me of likely problems before
I get as far as testing and debugging.
(Your project here looks very interesting - I'm going to have a good
look at it when I get the chance. I won't be able to use it directly,
as a pure GPL license basically makes it unusable for anything but
learning or hobby use, but as it matches ideas I have had myself I am
interested in how it works.)
> I've only had limited success coming up with a set of -f options to add
> to O0 to eliminate the unused objects but retain the un-optimized binary
> code. The above explains why, but it would be nice if the -O options
> really were just a set of -f ones and users could customize to their
> needs. Without implementing my specific "-O0.5" option. ;)
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-20 21:17 ` David Brown
@ 2021-01-21 3:53 ` mark_at_yahoo
2021-01-21 9:02 ` David Brown
0 siblings, 1 reply; 10+ messages in thread
From: mark_at_yahoo @ 2021-01-21 3:53 UTC (permalink / raw)
To: David Brown, gcc-help
On 1/20/21 1:17 PM, David Brown wrote:
> I /never/ use -O0, precisely because I find it absolutely terrible for
> assembly level debugging. You can't see the wood for the trees, as all
> local variables are on the stack, and even the simplest of C expressions
> ends up with large numbers of assembly instructions. In my experience -
> and this is obviously very subjective - using -O1 gives far more
> readable assembly code while avoiding the kinds of code re-arrangement
> and re-ordering of -O2 that makes assembly-level debugging difficult.
> (-Og is an alternative for modern gcc versions, which can give most of
> the speed of -O2 but is a little easier for debugging).
Interesting. My recollection is that -O0, regardless of variables being
on the stack, was more "linear": Each C statement was followed
more-or-less by the assembly code required to implement it, then the
next C statement and so on. In particular, variables in -O1 can get
tucked away into registers and "disappear" for long stretches of
assembly before popping up again, and the spaghetti-code jumping for
common code block elimination. Which is of course all good optimization,
but makes things hard to follow.
But I'll have to revisit the issue again.
> Another major benefit of -O1 is that it enables much more code analysis,
> which in turn enables much better static checking - I am a big fan of
> warning flags and having the compiler tell me of likely problems before
> I get as far as testing and debugging.
Me, too ("big fan").
> (Your project here looks very interesting - I'm going to have a good
> look at it when I get the chance. I won't be able to use it directly,
> as a pure GPL license basically makes it unusable for anything but
> learning or hobby use, but as it matches ideas I have had myself I am
> interested in how it works.)
Thanks. Yes, it's basically a simple idea, and I found out recently that
others have attempted something similar (which I wish I'd known when I
started doing it myself). This is now very off-topic for this list, but
I'd like to get your input, including the GPL vs LPGPL issue (ironic
given that this is a GNU mailing list). Maybe open an issue at the
Github repository and we can discuss it there?
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: In GCC 10.2, -O2 optimization enables more than docs suggest
2021-01-21 3:53 ` mark_at_yahoo
@ 2021-01-21 9:02 ` David Brown
0 siblings, 0 replies; 10+ messages in thread
From: David Brown @ 2021-01-21 9:02 UTC (permalink / raw)
To: mark_at_yahoo, gcc-help
On 21/01/2021 04:53, mark_at_yahoo wrote:
> On 1/20/21 1:17 PM, David Brown wrote:
>
>> I /never/ use -O0, precisely because I find it absolutely terrible for
>> assembly level debugging. You can't see the wood for the trees, as all
>> local variables are on the stack, and even the simplest of C expressions
>> ends up with large numbers of assembly instructions. In my experience -
>> and this is obviously very subjective - using -O1 gives far more
>> readable assembly code while avoiding the kinds of code re-arrangement
>> and re-ordering of -O2 that makes assembly-level debugging difficult.
>> (-Og is an alternative for modern gcc versions, which can give most of
>> the speed of -O2 but is a little easier for debugging).
>
> Interesting. My recollection is that -O0, regardless of variables being
> on the stack, was more "linear": Each C statement was followed
> more-or-less by the assembly code required to implement it, then the
> next C statement and so on.
Yes, that is true. But I find (and again this is my own experience,
which may not match others - it may also depend on the way you write
your code) that the amount of stack manipulation code makes it
impossible to see what is really happening. For each "arithmetic"
assembly line doing an add, you've got two or more loads and stores to
the stack. And when the "real" assembly is a load or a store, you can't
see it amongst all the other stack loads and stores.
It is even worse if you use C++. If you've got a few template classes
and overloaded operators, -O0 might lead you down a path of a dozen
nested function calls, each with their stack frames, when with -O1 you
have just the one assembly instruction that is actually relevant.
With -O1, the assembly for an "add one function :
int inc(int x) { return x + 1; }
is:
inc(int):
adds r0, r0, #1
bx lr
That's simple, easy to understand, easy to follow, easy to step through
at the assembly level.
With -O0, you get:
inc(int):
push {r7}
sub sp, sp, #12
add r7, sp, #0
str r0, [r7, #4]
ldr r3, [r7, #4]
adds r3, r3, #1
mov r0, r3
adds r7, r7, #12
mov sp, r7
ldr r7, [sp], #4
bx lr
I can't answer for anyone else, but I know which version /I/ would
rather try to follow.
> In particular, variables in -O1 can get
> tucked away into registers and "disappear" for long stretches of
> assembly before popping up again, and the spaghetti-code jumping for
> common code block elimination. Which is of course all good optimization,
> but makes things hard to follow.
With -O1, you get very little "spaghetti-jumping" - generated code
follows linear paths that match the source to a large extent. -O2 is a
different matter - that's when a lot more of the code re-ordering and
re-arranging comes in. Yes, -O1 puts data in registers - IMHO that is a
/good/ thing for debugging because it makes the code simpler and
clearer. And yes, it makes some code and variables "disappear". That
can be a good thing (clearing away unnecessary detail), or a bad thing.
Sometimes I'll temporarily add a "volatile" qualifier to a variable, or
a "no_inline" attribute to a function in order to make debugging easier.
That's part of the process. I actually do almost all of my
compilation with -O2 as the starting point (and various fine-tuning
flags) - and I do my debugging with that build. I strongly dislike the
idea of different debug/release builds, and do not make a
differentiation. If I need a lower optimisation to help trace an
awkward problem, I'll add a "#pragma optimize 1" line to the relevant code.
>
> But I'll have to revisit the issue again.
>
>
>> Another major benefit of -O1 is that it enables much more code analysis,
>> which in turn enables much better static checking - I am a big fan of
>> warning flags and having the compiler tell me of likely problems before
>> I get as far as testing and debugging.
>
> Me, too ("big fan").
Well, remember that "-O0" greatly limits these warnings.
IMHO, gcc should introduced a new warning that is enabled by default on
-O0, giving the message "You are using the world's most powerful
compiler, but you are crippling it with your choice of flags." There
should also be a warning if "-Wall" is not enabled.
(OK, perhaps that would be going a little too far...)
>
>
>> (Your project here looks very interesting - I'm going to have a good
>> look at it when I get the chance. I won't be able to use it directly,
>> as a pure GPL license basically makes it unusable for anything but
>> learning or hobby use, but as it matches ideas I have had myself I am
>> interested in how it works.)
>
> Thanks. Yes, it's basically a simple idea, and I found out recently that
> others have attempted something similar (which I wish I'd known when I
> started doing it myself). This is now very off-topic for this list, but
> I'd like to get your input, including the GPL vs LPGPL issue (ironic
> given that this is a GNU mailing list). Maybe open an issue at the
> Github repository and we can discuss it there?
I'll look through the project first, and then get back to you - either
through Github or your email address. In the meantime, you could look
at the licencing for FreeRTOS to see if its "GPL with exception" licence
suits you. (gcc also has a kind of "GPL with exception" licence,
otherwise it could not be used for anything other than GPL'ed code.)
mvh.,
David
^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2021-01-21 9:02 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-01-16 20:48 In GCC 10.2, -O2 optimization enables more than docs suggest Brent Roman
2021-01-20 15:56 ` Richard Earnshaw
2021-01-20 16:53 ` mark_at_yahoo
2021-01-20 18:50 ` Jonathan Wakely
2021-01-20 19:06 ` mark_at_yahoo
2021-01-20 19:44 ` Jonathan Wakely
2021-01-20 20:45 ` mark_at_yahoo
2021-01-20 21:17 ` David Brown
2021-01-21 3:53 ` mark_at_yahoo
2021-01-21 9:02 ` David Brown
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).