From: Richard Biener <rguenther@suse.de>
To: Segher Boessenkool <segher@kernel.crashing.org>
Cc: Michael Matz <matz@suse.de>, Borislav Petkov <bp@alien8.de>,
gcc@gcc.gnu.org, Nadav Amit <namit@vmware.com>,
Ingo Molnar <mingo@redhat.com>,
linux-kernel@vger.kernel.org, x86@kernel.org,
Masahiro Yamada <yamada.masahiro@socionext.com>,
Sam Ravnborg <sam@ravnborg.org>,
Alok Kataria <akataria@vmware.com>,
Christopher Li <sparse@chrisli.org>,
Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
"H. Peter Anvin" <hpa@zytor.com>, Jan Beulich <JBeulich@suse.com>,
Josh Poimboeuf <jpoimboe@redhat.com>,
Juergen Gross <jgross@suse.com>,
Kate Stewart <kstewart@linuxfoundation.org>,
Kees Cook <keescook@chromium.org>,
linux-sparse@vger.kernel.org,
Peter Zijlstra <peterz@infradead.org>,
Philippe Ombredanne <pombredanne@nexb.com>,
Thomas Gleixner <tglx@linutronix.de>,
virtualization@lists.linux-foundation.org,
Linus Torvalds <torvalds@linux-foundation.org>,
Chris Zankel <chris@zankel.net>,
Max Filippov <jcmvbkbc@gmail.com>,
linux-xtensa@linux-xtensa.org
Subject: Re: PROPOSAL: Extend inline asm syntax with size spec
Date: Mon, 8 Oct 2018 11:07:46 +0200 (CEST) [thread overview]
Message-ID: <alpine.LSU.2.20.1810081105350.16707@zhemvz.fhfr.qr> (raw)
In-Reply-To: <20181008073128.GL29268@gate.crashing.org>
On Mon, 8 Oct 2018, Segher Boessenkool wrote:
> Hi!
>
> On Sun, Oct 07, 2018 at 03:53:26PM +0000, Michael Matz wrote:
> > On Sun, 7 Oct 2018, Segher Boessenkool wrote:
> > > On Sun, Oct 07, 2018 at 11:18:06AM +0200, Borislav Petkov wrote:
> > > > this is an attempt to see whether gcc's inline asm heuristic when
> > > > estimating inline asm statements' cost for better inlining can be
> > > > improved.
> > >
> > > GCC already estimates the *size* of inline asm, and this is required
> > > *for correctness*. So any workaround that works against this will only
> > > end in tears.
> >
> > You're right and wrong. GCC can't even estimate the size of mildly
> > complicated inline asms right now, so your claim of it being necessary for
> > correctness can't be true in this absolute form. I know what you try to
> > say, but still, consider inline asms like this:
> >
> > insn1
> > .section bla
> > insn2
> > .previous
> >
> > or
> > invoke_asm_macro foo,bar
> >
> > in both cases GCCs size estimate will be wrong however you want to count
> > it. This is actually the motivating example for the kernel guys, the
> > games they play within their inline asms make the estimates be wildly
> > wrong to a point it interacts with the inliner.
>
> Right. The manual says:
>
> """
> Some targets require that GCC track the size of each instruction used
> in order to generate correct code. Because the final length of the
> code produced by an @code{asm} statement is only known by the
> assembler, GCC must make an estimate as to how big it will be. It
> does this by counting the number of instructions in the pattern of the
> @code{asm} and multiplying that by the length of the longest
> instruction supported by that processor. (When working out the number
> of instructions, it assumes that any occurrence of a newline or of
> whatever statement separator character is supported by the assembler --
> typically @samp{;} --- indicates the end of an instruction.)
>
> Normally, GCC's estimate is adequate to ensure that correct
> code is generated, but it is possible to confuse the compiler if you use
> pseudo instructions or assembler macros that expand into multiple real
> instructions, or if you use assembler directives that expand to more
> space in the object file than is needed for a single instruction.
> If this happens then the assembler may produce a diagnostic saying that
> a label is unreachable.
> """
>
> It *is* necessary for correctness, except you can do things that can
> confuse the compiler and then you are on your own anyway.
>
> > > So I guess the real issue is that the inline asm size estimate for x86
> > > isn't very good (since it has to be pessimistic, and x86 insns can be
> > > huge)?
> >
> > No, see above, even if we were to improve the size estimates (e.g. based
> > on some average instruction size) the kernel examples would still be off
> > because they switch sections back and forth, use asm macros and computed
> > .fill directives and maybe further stuff. GCC will never be able to
> > accurately calculate these sizes
>
> What *is* such a size, anyway? If it can be spread over multiple sections
> (some of which support section merging), and you can have huge alignments,
> etc. What is needed here is not knowing the maximum size of the binary
> output (however you want to define that), but some way for the compiler
> to understand how bad it is to inline some assembler. Maybe manual
> direction, maybe just the current jeuristics can be tweaked a bit, maybe
> we need to invent some attribute or two.
>
> > (without an built-in assembler which hopefully noone proposes).
>
> Not me, that's for sure.
>
> > So, there is a case for extending the inline-asm facility to say
> > "size is complicated here, assume this for inline decisions".
>
> Yeah, that's an option. It may be too complicated though, or just not
> useful in its generality, so that everyone will use "1" (or "1 normal
> size instruction"), and then we are better off just making something
> for _that_ (or making it the default).
>
> > > > Now, Richard suggested doing something like:
> > > >
> > > > 1) inline asm ("...")
> > >
> > > What would the semantics of this be?
> >
> > The size of the inline asm wouldn't be counted towards the inliner size
> > limits (or be counted as "1").
>
> That sounds like a good option.
Yes, I also like it for simplicity. It also avoids the requirement
of translating the number (in bytes?) given by the user to
"number of GIMPLE instructions" as needed by the inliner.
> > > I don't like 2) either. But 1) looks interesting, depends what its
> > > semantics would be? "Don't count this insn's size for inlining decisions",
> > > maybe?
> >
> > TBH, I like the inline asm (...) suggestion most currently, but what if we
> > want to add more attributes to asms? We could add further special
> > keywords to the clobber list:
> > asm ("...." : : : "cc,memory,inline");
> > sure, it might seem strange to "clobber" inline, but if we reinterpret the
> > clobber list as arbitrary set of attributes for this asm, it'd be fine.
>
> All of a targets register names and alternative register names are
> allowed in the clobber list. Will that never conflict with an attribute
> name? We already *have* syntax for specifying attributes on an asm (on
> *any* statement even), so mixing these two things has no advantage.
Heh, but I failed to make an example with attribute synatx working.
IIRC attributes do not work on stmts. What could work is to use
a #pragma though.
Richard.
> Both "cc" and "memory" have their own problems of course, adding more
> things to this just feels bad. It may not be so bad ;-)
>
> > > Another option is to just force inlining for those few functions where
> > > GCC currently makes an inlining decision you don't like. Or are there
> > > more than a few?
> >
> > I think the examples I saw from Boris were all indirect inlines:
> >
> > static inline void foo() { asm("large-looking-but-small-asm"); }
> > static void bar1() { ... foo() ... }
> > static void bar2() { ... foo() ... }
> > void goo (void) { bar1(); } // bar1 should have been inlined
> >
> > So, while the immediate asm user was marked as always inline that in turn
> > caused users of it to become non-inlined. I'm assuming the kernel guys
> > did proper measurements that they _really_ get some non-trivial speed
> > benefit by inlining bar1/bar2, but for some reasons (I didn't inquire)
> > didn't want to mark them all as inline as well.
>
> Yeah that makes sense, like if this happens with the fixup stuff, it will
> quickly spiral out of control.
next prev parent reply other threads:[~2018-10-08 9:07 UTC|newest]
Thread overview: 116+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-10-03 21:30 [PATCH v9 00/10] x86: macrofying inline asm Nadav Amit
2018-10-03 21:30 ` [PATCH v9 01/10] xtensa: defining LINKER_SCRIPT for the linker script Nadav Amit
2018-10-04 10:00 ` [tip:x86/build] kbuild/arch/xtensa: Define " tip-bot for Nadav Amit
2018-10-03 21:30 ` [PATCH v9 02/10] Makefile: Prepare for using macros for inline asm Nadav Amit
2018-10-04 10:01 ` [tip:x86/build] kbuild/Makefile: Prepare for using macros in inline assembly code to work around asm() related GCC inlining bugs tip-bot for Nadav Amit
2018-11-06 18:57 ` [PATCH v9 02/10] Makefile: Prepare for using macros for inline asm Logan Gunthorpe
2018-11-06 19:18 ` Nadav Amit
2018-11-06 20:01 ` Logan Gunthorpe
2018-11-07 18:01 ` Nadav Amit
2018-11-07 18:53 ` Logan Gunthorpe
2018-11-07 18:56 ` Nadav Amit
2018-11-07 21:43 ` Logan Gunthorpe
2018-11-07 21:50 ` hpa
2018-11-08 6:18 ` Nadav Amit
2018-11-08 17:14 ` Logan Gunthorpe
2018-11-08 19:54 ` Nadav Amit
2018-11-08 20:00 ` Logan Gunthorpe
2018-11-08 20:18 ` Nadav Amit
2018-11-10 22:04 ` Nadav Amit
2018-11-13 4:56 ` Logan Gunthorpe
2018-10-03 21:30 ` [PATCH v9 03/10] x86: objtool: use asm macro for better compiler decisions Nadav Amit
2018-10-04 10:02 ` [tip:x86/build] x86/objtool: Use asm macros to work around GCC inlining bugs tip-bot for Nadav Amit
2018-10-03 21:30 ` [PATCH v9 04/10] x86: refcount: prevent gcc distortions Nadav Amit
2018-10-04 7:57 ` Ingo Molnar
2018-10-04 8:33 ` Ingo Molnar
2018-10-04 8:40 ` hpa
2018-10-04 8:56 ` Ingo Molnar
2018-10-04 8:56 ` Nadav Amit
2018-10-04 9:02 ` hpa
2018-10-04 9:16 ` Ingo Molnar
2018-10-04 19:33 ` H. Peter Anvin
2018-10-04 20:05 ` Nadav Amit
2018-10-04 20:08 ` H. Peter Anvin
2018-10-04 20:29 ` Andy Lutomirski
2018-10-04 23:11 ` H. Peter Anvin
2018-10-06 1:40 ` Rasmus Villemoes
2018-10-04 9:12 ` Ingo Molnar
2018-10-04 9:17 ` hpa
2018-10-04 9:30 ` Nadav Amit
2018-10-04 9:45 ` Ingo Molnar
2018-10-04 10:23 ` Nadav Amit
2018-10-05 9:31 ` Ingo Molnar
2018-10-05 11:20 ` Borislav Petkov
2018-10-05 12:52 ` Ingo Molnar
2018-10-05 20:27 ` [PATCH 0/3] Macrofying inline asm rebased Nadav Amit
2018-10-05 20:27 ` [PATCH 1/3] x86/extable: Macrofy inline assembly code to work around GCC inlining bugs Nadav Amit
2018-10-06 14:42 ` [tip:x86/build] " tip-bot for Nadav Amit
2018-10-05 20:27 ` [PATCH 2/3] x86/cpufeature: " Nadav Amit
2018-10-06 14:43 ` [tip:x86/build] " tip-bot for Nadav Amit
2018-10-05 20:27 ` [PATCH 3/3] x86/jump-labels: " Nadav Amit
2018-10-06 14:44 ` [tip:x86/build] " tip-bot for Nadav Amit
2018-10-08 2:17 ` [PATCH v9 04/10] x86: refcount: prevent gcc distortions Nadav Amit
2018-10-04 8:40 ` Nadav Amit
2018-10-04 9:01 ` Ingo Molnar
2018-10-04 10:02 ` [tip:x86/build] x86/refcount: Work around GCC inlining bug tip-bot for Nadav Amit
2018-10-03 21:30 ` [PATCH v9 05/10] x86: alternatives: macrofy locks for better inlining Nadav Amit
2018-10-04 10:03 ` [tip:x86/build] x86/alternatives: Macrofy lock prefixes to work around GCC inlining bugs tip-bot for Nadav Amit
2018-10-03 21:30 ` [PATCH v9 06/10] x86: bug: prevent gcc distortions Nadav Amit
2018-10-04 10:03 ` [tip:x86/build] x86/bug: Macrofy the BUG table section handling, to work around GCC inlining bugs tip-bot for Nadav Amit
2018-10-03 21:30 ` [PATCH v9 07/10] x86: prevent inline distortion by paravirt ops Nadav Amit
2018-10-04 10:04 ` [tip:x86/build] x86/paravirt: Work around GCC inlining bugs when compiling " tip-bot for Nadav Amit
2018-10-03 21:30 ` [PATCH v9 08/10] x86: extable: use macros instead of inline assembly Nadav Amit
2018-10-03 21:30 ` [PATCH v9 09/10] x86: cpufeature: " Nadav Amit
2018-10-03 21:31 ` [PATCH v9 10/10] x86: jump-labels: " Nadav Amit
2018-10-07 9:18 ` PROPOSAL: Extend inline asm syntax with size spec Borislav Petkov
[not found] ` <20181007132228.GJ29268@gate.crashing.org>
2018-10-07 14:13 ` Borislav Petkov
2018-10-07 15:14 ` Segher Boessenkool
2018-10-08 5:58 ` Ingo Molnar
2018-10-08 7:53 ` Segher Boessenkool
2018-10-07 15:53 ` Michael Matz
2018-10-08 6:13 ` Ingo Molnar
2018-10-08 8:18 ` Segher Boessenkool
2018-10-08 7:31 ` Segher Boessenkool
2018-10-08 9:07 ` Richard Biener [this message]
2018-10-08 10:02 ` Segher Boessenkool
2018-10-09 14:53 ` Segher Boessenkool
2018-10-10 6:35 ` Ingo Molnar
2018-10-10 7:12 ` Richard Biener
2018-10-10 7:22 ` Ingo Molnar
2018-10-10 8:03 ` Segher Boessenkool
2018-10-10 8:19 ` Borislav Petkov
2018-10-10 8:35 ` Richard Biener
2018-10-10 18:54 ` Segher Boessenkool
2018-10-10 19:14 ` Borislav Petkov
2018-10-13 19:33 ` Borislav Petkov
2018-10-13 21:14 ` Alexander Monakov
2018-10-13 21:30 ` Borislav Petkov
2018-10-25 10:24 ` Borislav Petkov
2018-10-31 12:55 ` Peter Zijlstra
2018-10-31 13:11 ` Peter Zijlstra
2018-10-31 16:31 ` Segher Boessenkool
2018-11-01 5:20 ` Joe Perches
2018-11-01 9:01 ` Peter Zijlstra
2018-11-01 9:20 ` Joe Perches
2018-11-01 11:15 ` Peter Zijlstra
2018-12-27 4:47 ` Masahiro Yamada
2018-10-10 10:29 ` Richard Biener
2018-10-10 7:53 ` Segher Boessenkool
2018-10-10 16:31 ` Nadav Amit
2018-10-10 19:21 ` Segher Boessenkool
2018-10-11 7:04 ` Richard Biener
2018-11-29 11:46 ` Masahiro Yamada
2018-11-29 12:25 ` Segher Boessenkool
2018-11-30 9:06 ` Boris Petkov
2018-11-30 13:16 ` Segher Boessenkool
2018-12-10 8:16 ` Masahiro Yamada
2018-11-29 13:07 ` Borislav Petkov
2018-11-29 13:09 ` Richard Biener
2018-11-29 13:16 ` Borislav Petkov
2018-11-29 13:24 ` Richard Biener
2018-10-08 16:24 ` David Laight
2018-10-07 16:09 ` Nadav Amit
2018-10-07 16:46 ` Richard Biener
2018-10-07 19:06 ` Nadav Amit
2018-10-07 19:52 ` Jeff Law
2018-10-08 7:46 ` Richard Biener
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=alpine.LSU.2.20.1810081105350.16707@zhemvz.fhfr.qr \
--to=rguenther@suse.de \
--cc=JBeulich@suse.com \
--cc=akataria@vmware.com \
--cc=bp@alien8.de \
--cc=chris@zankel.net \
--cc=gcc@gcc.gnu.org \
--cc=gregkh@linuxfoundation.org \
--cc=hpa@zytor.com \
--cc=jcmvbkbc@gmail.com \
--cc=jgross@suse.com \
--cc=jpoimboe@redhat.com \
--cc=keescook@chromium.org \
--cc=kstewart@linuxfoundation.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-sparse@vger.kernel.org \
--cc=linux-xtensa@linux-xtensa.org \
--cc=matz@suse.de \
--cc=mingo@redhat.com \
--cc=namit@vmware.com \
--cc=peterz@infradead.org \
--cc=pombredanne@nexb.com \
--cc=sam@ravnborg.org \
--cc=segher@kernel.crashing.org \
--cc=sparse@chrisli.org \
--cc=tglx@linutronix.de \
--cc=torvalds@linux-foundation.org \
--cc=virtualization@lists.linux-foundation.org \
--cc=x86@kernel.org \
--cc=yamada.masahiro@socionext.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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 NNTP newsgroup(s).