From: Segher Boessenkool <segher@kernel.crashing.org>
To: Richard Biener <rguenther@suse.de>
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: Tue, 9 Oct 2018 09:53:30 -0500 [thread overview]
Message-ID: <20181009145330.GT29268@gate.crashing.org> (raw)
In-Reply-To: <alpine.LSU.2.20.1810081105350.16707@zhemvz.fhfr.qr>
On Mon, Oct 08, 2018 at 11:07:46AM +0200, Richard Biener wrote:
> On Mon, 8 Oct 2018, Segher Boessenkool wrote:
> > 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:
> > > > > 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.
This patch implements this, for C only so far. And the syntax is
"asm inline", which is more in line with other syntax.
How does this look?
Segher
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index 1f173fc..94b1d41 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -6287,7 +6287,7 @@ static tree
c_parser_asm_statement (c_parser *parser)
{
tree quals, str, outputs, inputs, clobbers, labels, ret;
- bool simple, is_goto;
+ bool simple, is_goto, is_inline;
location_t asm_loc = c_parser_peek_token (parser)->location;
int section, nsections;
@@ -6318,6 +6318,13 @@ c_parser_asm_statement (c_parser *parser)
is_goto = true;
}
+ is_inline = false;
+ if (c_parser_next_token_is_keyword (parser, RID_INLINE))
+ {
+ c_parser_consume_token (parser);
+ is_inline = true;
+ }
+
/* ??? Follow the C++ parser rather than using the
lex_untranslated_string kludge. */
parser->lex_untranslated_string = true;
@@ -6393,7 +6400,8 @@ c_parser_asm_statement (c_parser *parser)
c_parser_skip_to_end_of_block_or_statement (parser);
ret = build_asm_stmt (quals, build_asm_expr (asm_loc, str, outputs, inputs,
- clobbers, labels, simple));
+ clobbers, labels, simple,
+ is_inline));
error:
parser->lex_untranslated_string = false;
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 017c01c..f5629300 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -677,7 +677,8 @@ extern tree build_compound_literal (location_t, tree, tree, bool,
extern void check_compound_literal_type (location_t, struct c_type_name *);
extern tree c_start_case (location_t, location_t, tree, bool);
extern void c_finish_case (tree, tree);
-extern tree build_asm_expr (location_t, tree, tree, tree, tree, tree, bool);
+extern tree build_asm_expr (location_t, tree, tree, tree, tree, tree, bool,
+ bool);
extern tree build_asm_stmt (tree, tree);
extern int c_types_compatible_p (tree, tree);
extern tree c_begin_compound_stmt (bool);
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 9d09b8d..e013100 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -10064,7 +10064,7 @@ build_asm_stmt (tree cv_qualifier, tree args)
are subtly different. We use a ASM_EXPR node to represent this. */
tree
build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
- tree clobbers, tree labels, bool simple)
+ tree clobbers, tree labels, bool simple, bool is_inline)
{
tree tail;
tree args;
@@ -10182,6 +10182,7 @@ build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
as volatile. */
ASM_INPUT_P (args) = simple;
ASM_VOLATILE_P (args) = (noutputs == 0);
+ ASM_INLINE_P (args) = is_inline;
return args;
}
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 83e2273..1a00fa3 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -2019,6 +2019,8 @@ dump_gimple_asm (pretty_printer *buffer, gasm *gs, int spc, dump_flags_t flags)
pp_string (buffer, "__asm__");
if (gimple_asm_volatile_p (gs))
pp_string (buffer, " __volatile__");
+ if (gimple_asm_inline_p (gs))
+ pp_string (buffer, " __inline__");
if (gimple_asm_nlabels (gs))
pp_string (buffer, " goto");
pp_string (buffer, "(\"");
diff --git a/gcc/gimple.h b/gcc/gimple.h
index a5dda93..8a58e07 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -137,6 +137,7 @@ enum gimple_rhs_class
enum gf_mask {
GF_ASM_INPUT = 1 << 0,
GF_ASM_VOLATILE = 1 << 1,
+ GF_ASM_INLINE = 1 << 2,
GF_CALL_FROM_THUNK = 1 << 0,
GF_CALL_RETURN_SLOT_OPT = 1 << 1,
GF_CALL_TAILCALL = 1 << 2,
@@ -3911,7 +3912,7 @@ gimple_asm_volatile_p (const gasm *asm_stmt)
}
-/* If VOLATLE_P is true, mark asm statement ASM_STMT as volatile. */
+/* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile. */
static inline void
gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
@@ -3923,6 +3924,27 @@ gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
}
+/* Return true ASM_STMT ASM_STMT is an asm statement marked inline. */
+
+static inline bool
+gimple_asm_inline_p (const gasm *asm_stmt)
+{
+ return (asm_stmt->subcode & GF_ASM_INLINE) != 0;
+}
+
+
+/* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
+
+static inline void
+gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
+{
+ if (inline_p)
+ asm_stmt->subcode |= GF_ASM_INLINE;
+ else
+ asm_stmt->subcode &= ~GF_ASM_INLINE;
+}
+
+
/* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT. */
static inline void
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 509fc2f..10b80f2 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -6315,6 +6315,7 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
+ gimple_asm_set_inline (stmt, ASM_INLINE_P (expr));
gimplify_seq_add_stmt (pre_p, stmt);
}
diff --git a/gcc/ipa-icf-gimple.c b/gcc/ipa-icf-gimple.c
index ba39ea3..5361139 100644
--- a/gcc/ipa-icf-gimple.c
+++ b/gcc/ipa-icf-gimple.c
@@ -993,6 +993,9 @@ func_checker::compare_gimple_asm (const gasm *g1, const gasm *g2)
if (gimple_asm_input_p (g1) != gimple_asm_input_p (g2))
return false;
+ if (gimple_asm_inline_p (g1) != gimple_asm_inline_p (g2))
+ return false;
+
if (gimple_asm_ninputs (g1) != gimple_asm_ninputs (g2))
return false;
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 9134253..6b1d2ea 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -4108,6 +4108,8 @@ estimate_num_insns (gimple *stmt, eni_weights *weights)
with very long asm statements. */
if (count > 1000)
count = 1000;
+ if (gimple_asm_inline_p (as_a <gasm *> (stmt)))
+ count = !!count;
return MAX (1, count);
}
diff --git a/gcc/tree.h b/gcc/tree.h
index 2e45f9d..160b3a7 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1245,6 +1245,9 @@ extern tree maybe_wrap_with_location (tree, location_t);
ASM_OPERAND with no operands. */
#define ASM_INPUT_P(NODE) (ASM_EXPR_CHECK (NODE)->base.static_flag)
#define ASM_VOLATILE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.public_flag)
+/* Nonzero if we want to consider this asm as minimum length and cost
+ for inlining decisions. */
+#define ASM_INLINE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.protected_flag)
/* COND_EXPR accessors. */
#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
next prev parent reply other threads:[~2018-10-09 16:12 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
2018-10-08 10:02 ` Segher Boessenkool
2018-10-09 14:53 ` Segher Boessenkool [this message]
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=20181009145330.GT29268@gate.crashing.org \
--to=segher@kernel.crashing.org \
--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=rguenther@suse.de \
--cc=sam@ravnborg.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).