From 490bd1ff02b9d0e37a0aec334c1be80d54ed3ab6 Mon Sep 17 00:00:00 2001 From: Patrick J Volkerding Date: Tue, 5 Mar 2019 00:17:16 +0000 Subject: Tue Mar 5 00:17:16 UTC 2019 d/gcc-8.3.0-x86_64-2.txz: Rebuilt. Reverted backported asm inline patches that broke "asm volatile". Thanks to nobodino. d/gcc-brig-8.3.0-x86_64-2.txz: Rebuilt. d/gcc-g++-8.3.0-x86_64-2.txz: Rebuilt. d/gcc-gfortran-8.3.0-x86_64-2.txz: Rebuilt. d/gcc-gnat-8.3.0-x86_64-2.txz: Rebuilt. d/gcc-go-8.3.0-x86_64-2.txz: Rebuilt. d/gcc-objc-8.3.0-x86_64-2.txz: Rebuilt. l/at-spi2-atk-2.30.1-x86_64-1.txz: Upgraded. l/at-spi2-core-2.30.1-x86_64-1.txz: Upgraded. l/gc-8.0.4-x86_64-1.txz: Upgraded. l/glib2-2.60.0-x86_64-1.txz: Upgraded. l/imagemagick-6.9.10_31-x86_64-1.txz: Upgraded. n/postfix-3.4.0-x86_64-2.txz: Rebuilt. Prevent the install script from making noise. x/xinit-1.4.1-x86_64-1.txz: Upgraded. x/xlogo-1.0.5-x86_64-1.txz: Upgraded. x/xmore-1.0.3-x86_64-1.txz: Upgraded. extra/fltk/fltk-1.3.5-x86_64-1.txz: Upgraded. --- .../patches/revert-asm-inline/2-8-asm-inline.patch | 577 +++++++++++++++++++++ 1 file changed, 577 insertions(+) create mode 100644 source/d/gcc/patches/revert-asm-inline/2-8-asm-inline.patch (limited to 'source/d/gcc/patches/revert-asm-inline/2-8-asm-inline.patch') diff --git a/source/d/gcc/patches/revert-asm-inline/2-8-asm-inline.patch b/source/d/gcc/patches/revert-asm-inline/2-8-asm-inline.patch new file mode 100644 index 000000000..9ffb77a89 --- /dev/null +++ b/source/d/gcc/patches/revert-asm-inline/2-8-asm-inline.patch @@ -0,0 +1,577 @@ +From patchwork Thu Dec 27 14:59:07 2018 +Content-Type: text/plain; charset="utf-8" +MIME-Version: 1.0 +Content-Transfer-Encoding: 7bit +Subject: [2/8] asm inline +X-Patchwork-Submitter: Segher Boessenkool +X-Patchwork-Id: 13820 +Message-Id: <420ded3dc643d9e1ee6239ca5a8d1942c69bfe76.1545922222.git.segher@kernel.crashing.org> +To: gcc-patches@gcc.gnu.org +Cc: Segher Boessenkool +Date: Thu, 27 Dec 2018 14:59:07 +0000 +From: Segher Boessenkool +List-Id: + +The Linux kernel people want a feature that makes GCC pretend some +inline assembler code is tiny (while it would think it is huge), so +that such code will be inlined essentially always instead of +essentially never. + +This patch lets you say "asm inline" instead of just "asm", with the +result that that inline assembler is always counted as minimum cost +for inlining. It implements this for C and C++, making "inline" +another asm-qualifier (supplementing "volatile" and "goto"). + +2018-12-06 Segher Boessenkool + + * doc/extend.texi (Using Assembly Language with C): Document asm inline. + (Size of an asm): Fix typo. Document asm inline. + * gimple-pretty-print.c (dump_gimple_asm): Handle asm inline. + * gimple.h (enum gf_mask): Add GF_ASM_INLINE. + (gimple_asm_set_volatile): Fix typo. + (gimple_asm_inline_p): New. + (gimple_asm_set_inline): New. + * gimplify.c (gimplify_asm_expr): Propagate the asm inline flag from + tree to gimple. + * ipa-icf-gimple.c (func_checker::compare_gimple_asm): Compare the + gimple_asm_inline_p flag, too. + * tree-core.h (tree_base): Document that protected_flag is ASM_INLINE_P + in an ASM_EXPR. + * tree-inline.c (estimate_num_insns): If gimple_asm_inline_p return + a minimum size for an asm. + * tree.h (ASM_INLINE_P): New. + +gcc/c/ + * c-parser.c (c_parser_asm_statement): Detect the inline keyword + after asm. Pass a flag for it to build_asm_expr. + * c-tree.h (build_asm_expr): Update declaration. + * c-typeck.c (build_asm_stmt): Add is_inline parameter. Use it to + set ASM_INLINE_P. + +gcc/cp/ + * cp-tree.h (finish_asm_stmt): Update declaration. + * parser.c (cp_parser_asm_definition): Detect the inline keyword + after asm. Pass a flag for it to finish_asm_stmt. + * pt.c (tsubst_expr): Pass the ASM_INLINE_P flag to finish_asm_stmt. + * semantics.c (finish_asm_stmt): Add inline_p parameter. Use it to + set ASM_INLINE_P. + +gcc/testsuite/ + * c-c++-common/torture/asm-inline.c: New testcase. + * gcc.dg/asm-qual-2.c: Test asm inline, too. +--- + gcc/c/c-parser.c | 21 ++++++++-- + gcc/c/c-tree.h | 3 +- + gcc/c/c-typeck.c | 7 +++- + gcc/cp/cp-tree.h | 2 +- + gcc/cp/parser.c | 15 ++++++- + gcc/cp/pt.c | 2 +- + gcc/cp/semantics.c | 5 ++- + gcc/doc/extend.texi | 15 ++++++- + gcc/gimple-pretty-print.c | 2 + + gcc/gimple.h | 26 +++++++++++- + gcc/gimplify.c | 1 + + gcc/ipa-icf-gimple.c | 3 ++ + gcc/testsuite/c-c++-common/torture/asm-inline.c | 53 +++++++++++++++++++++++++ + gcc/testsuite/gcc.dg/asm-qual-2.c | 25 ++++++++++++ + gcc/tree-core.h | 3 ++ + gcc/tree-inline.c | 3 ++ + gcc/tree.h | 3 ++ + 17 files changed, 174 insertions(+), 15 deletions(-) + create mode 100644 gcc/testsuite/c-c++-common/torture/asm-inline.c + +-- +1.8.3.1 + +diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c +index 7ec53b3..51cc2be 100644 +--- a/gcc/c/c-parser.c ++++ b/gcc/c/c-parser.c +@@ -6261,11 +6261,12 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll, + } + + /* Parse an asm statement, a GNU extension. This is a full-blown asm +- statement with inputs, outputs, clobbers, and volatile and goto tag +- allowed. ++ statement with inputs, outputs, clobbers, and volatile, inline, and goto ++ tags allowed. + + asm-qualifier: + volatile ++ inline + goto + + asm-qualifier-list: +@@ -6292,7 +6293,7 @@ static tree + c_parser_asm_statement (c_parser *parser) + { + tree quals, str, outputs, inputs, clobbers, labels, ret; +- bool simple, is_volatile, is_goto; ++ bool simple, is_volatile, is_inline, is_goto; + location_t asm_loc = c_parser_peek_token (parser)->location; + int section, nsections; + +@@ -6301,6 +6302,7 @@ c_parser_asm_statement (c_parser *parser) + + quals = NULL_TREE; + is_volatile = false; ++ is_inline = false; + is_goto = false; + for (bool done = false; !done; ) + switch (c_parser_peek_token (parser)->keyword) +@@ -6315,6 +6317,16 @@ c_parser_asm_statement (c_parser *parser) + else + done = true; + break; ++ case RID_INLINE: ++ if (!is_inline) ++ { ++ is_inline = true; ++ quals = c_parser_peek_token (parser)->value; ++ c_parser_consume_token (parser); ++ } ++ else ++ done = true; ++ break; + case RID_GOTO: + if (!is_goto) + { +@@ -6403,7 +6415,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 ae1a1e6..7f34bdc 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 8205916..3ebb28e 100644 +--- a/gcc/c/c-typeck.c ++++ b/gcc/c/c-typeck.c +@@ -9990,10 +9990,12 @@ build_asm_stmt (tree cv_qualifier, tree args) + some INPUTS, and some CLOBBERS. The latter three may be NULL. + SIMPLE indicates whether there was anything at all after the + string in the asm expression -- asm("blah") and asm("blah" : ) +- are subtly different. We use a ASM_EXPR node to represent this. */ ++ are subtly different. We use a ASM_EXPR node to represent this. ++ LOC is the location of the asm, and IS_INLINE says whether this ++ is asm inline. */ + 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; +@@ -10111,6 +10113,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/cp/cp-tree.h b/gcc/cp/cp-tree.h +index 85ba5b8..0f24b4f 100644 +--- a/gcc/cp/cp-tree.h ++++ b/gcc/cp/cp-tree.h +@@ -6897,7 +6897,7 @@ extern tree begin_compound_stmt (unsigned int); + + extern void finish_compound_stmt (tree); + extern tree finish_asm_stmt (int, tree, tree, tree, tree, +- tree); ++ tree, bool); + extern tree finish_label_stmt (tree); + extern void finish_label_decl (tree); + extern cp_expr finish_parenthesized_expr (cp_expr); +diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c +index 3bc5795..3fd9a02 100644 +--- a/gcc/cp/parser.c ++++ b/gcc/cp/parser.c +@@ -19069,6 +19069,7 @@ cp_parser_using_directive (cp_parser* parser) + + asm-qualifier: + volatile ++ inline + goto + + asm-qualifier-list: +@@ -19109,6 +19110,7 @@ cp_parser_asm_definition (cp_parser* parser) + bool extended_p = false; + bool invalid_inputs_p = false; + bool invalid_outputs_p = false; ++ bool inline_p = false; + bool goto_p = false; + required_token missing = RT_NONE; + +@@ -19138,6 +19140,17 @@ cp_parser_asm_definition (cp_parser* parser) + else + done = true; + break; ++ case RID_INLINE: ++ if (!inline_p && parser->in_function_body) ++ { ++ /* Remember that we saw the `inline' keyword. */ ++ inline_p = true; ++ /* Consume the token. */ ++ cp_lexer_consume_token (parser->lexer); ++ } ++ else ++ done = true; ++ break; + case RID_GOTO: + if (!goto_p && parser->in_function_body) + { +@@ -19279,7 +19292,7 @@ cp_parser_asm_definition (cp_parser* parser) + if (parser->in_function_body) + { + asm_stmt = finish_asm_stmt (volatile_p, string, outputs, +- inputs, clobbers, labels); ++ inputs, clobbers, labels, inline_p); + /* If the extended syntax was not used, mark the ASM_EXPR. */ + if (!extended_p) + { +diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c +index e9a9ac9..446f4fb 100644 +--- a/gcc/cp/pt.c ++++ b/gcc/cp/pt.c +@@ -16990,7 +16990,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, + tree labels = tsubst_copy_asm_operands (ASM_LABELS (t), args, + complain, in_decl); + tmp = finish_asm_stmt (ASM_VOLATILE_P (t), string, outputs, inputs, +- clobbers, labels); ++ clobbers, labels, ASM_INLINE_P (t)); + tree asm_expr = tmp; + if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR) + asm_expr = TREE_OPERAND (asm_expr, 0); +diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c +index 1744ec0..1f6c9be 100644 +--- a/gcc/cp/semantics.c ++++ b/gcc/cp/semantics.c +@@ -1461,11 +1461,11 @@ finish_compound_stmt (tree stmt) + /* Finish an asm-statement, whose components are a STRING, some + OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some + LABELS. Also note whether the asm-statement should be +- considered volatile. */ ++ considered volatile, and whether it is asm inline. */ + + tree + finish_asm_stmt (int volatile_p, tree string, tree output_operands, +- tree input_operands, tree clobbers, tree labels) ++ tree input_operands, tree clobbers, tree labels, bool inline_p) + { + tree r; + tree t; +@@ -1619,6 +1619,7 @@ finish_asm_stmt (int volatile_p, tree string, tree output_operands, + output_operands, input_operands, + clobbers, labels); + ASM_VOLATILE_P (r) = volatile_p || noutputs == 0; ++ ASM_INLINE_P (r) = inline_p; + r = maybe_cleanup_point_expr_void (r); + return add_stmt (r); + } +diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi +index 40b1989..4ff37c4 100644 +--- a/gcc/doc/extend.texi ++++ b/gcc/doc/extend.texi +@@ -8160,6 +8160,10 @@ various @option{-std} options, use @code{__asm__} instead of + @item volatile + The optional @code{volatile} qualifier has no effect. + All basic @code{asm} blocks are implicitly volatile. ++ ++@item inline ++If you use the @code{inline} qualifier, then for inlining purposes the size ++of the asm is taken as the smallest size possible (@pxref{Size of an asm}). + @end table + + @subsubheading Parameters +@@ -8303,6 +8307,10 @@ values to produce output values. However, your @code{asm} statements may + also produce side effects. If so, you may need to use the @code{volatile} + qualifier to disable certain optimizations. @xref{Volatile}. + ++@item inline ++If you use the @code{inline} qualifier, then for inlining purposes the size ++of the asm is taken as the smallest size possible (@pxref{Size of an asm}). ++ + @item goto + This qualifier informs the compiler that the @code{asm} statement may + perform a jump to one of the labels listed in the @var{GotoLabels}. +@@ -9714,7 +9722,7 @@ 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 -- ++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 +@@ -9725,6 +9733,11 @@ 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. + ++@cindex @code{asm inline} ++This size is also used for inlining decisions. If you use @code{asm inline} ++instead of just @code{asm}, then for inlining purposes the size of the asm ++is taken as the minimum size, ignoring how many instructions GCC thinks it is. ++ + @node Alternate Keywords + @section Alternate Keywords + @cindex alternate keywords +diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c +index 6695526..487770f 100644 +--- a/gcc/gimple-pretty-print.c ++++ b/gcc/gimple-pretty-print.c +@@ -2040,6 +2040,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 265e3e2..224463b 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, +@@ -3925,7 +3926,7 @@ gimple_asm_string (const gasm *asm_stmt) + } + + +-/* Return true ASM_STMT ASM_STMT is an asm statement marked volatile. */ ++/* Return true if ASM_STMT is marked volatile. */ + + static inline bool + gimple_asm_volatile_p (const gasm *asm_stmt) +@@ -3934,7 +3935,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) +@@ -3946,6 +3947,27 @@ gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p) + } + + ++/* Return true if ASM_STMT is 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 43cb891..fce0ce9 100644 +--- a/gcc/gimplify.c ++++ b/gcc/gimplify.c +@@ -6360,6 +6360,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 161080c..37b9fe7 100644 +--- a/gcc/ipa-icf-gimple.c ++++ b/gcc/ipa-icf-gimple.c +@@ -994,6 +994,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/testsuite/c-c++-common/torture/asm-inline.c b/gcc/testsuite/c-c++-common/torture/asm-inline.c +new file mode 100644 +index 0000000..dea8965 +--- /dev/null ++++ b/gcc/testsuite/c-c++-common/torture/asm-inline.c +@@ -0,0 +1,53 @@ ++/* { dg-do compile } */ ++/* -O0 does no inlining, and -O3 does it too aggressively for this test: */ ++/* { dg-skip-if "" { *-*-* } { "-O0" "-O3" } { "" } } ++/* The normal asm is not inlined: */ ++/* { dg-final { scan-assembler-times "w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w.w" 2 } } */ ++/* But the asm inline is inlined: */ ++/* { dg-final { scan-assembler-times "x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x" 8 } } */ ++ ++static void f(void) ++{ ++ asm ("w\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\n" ++ "w\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw"); ++} ++ ++int f0(void) { f(); return 0; } ++int f1(void) { f(); return 1; } ++int f2(void) { f(); return 2; } ++int f3(void) { f(); return 3; } ++ ++static void fg(void) ++{ ++ asm goto("w\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\n" ++ "w\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw\nw" :::: q); ++ q: ; ++} ++ ++int fg0(void) { fg(); return 0; } ++int fg1(void) { fg(); return 1; } ++int fg2(void) { fg(); return 2; } ++int fg3(void) { fg(); return 3; } ++ ++static void g(void) ++{ ++ asm inline("x\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\n" ++ "x\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx"); ++} ++ ++int g0(void) { g(); return 0; } ++int g1(void) { g(); return 1; } ++int g2(void) { g(); return 2; } ++int g3(void) { g(); return 3; } ++ ++static void gg(void) ++{ ++ asm inline goto("x\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\n" ++ "x\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx\nx" :::: q); ++ q: ; ++} ++ ++int gg0(void) { gg(); return 0; } ++int gg1(void) { gg(); return 1; } ++int gg2(void) { gg(); return 2; } ++int gg3(void) { gg(); return 3; } +diff --git a/gcc/testsuite/gcc.dg/asm-qual-2.c b/gcc/testsuite/gcc.dg/asm-qual-2.c +index 37df2ad..79135c3 100644 +--- a/gcc/testsuite/gcc.dg/asm-qual-2.c ++++ b/gcc/testsuite/gcc.dg/asm-qual-2.c +@@ -6,7 +6,18 @@ void + f (void) + { + asm volatile goto ("" :::: lab); ++ asm volatile inline ("" :::); ++ asm inline volatile ("" :::); ++ asm inline goto ("" :::: lab); + asm goto volatile ("" :::: lab); ++ asm goto inline ("" :::: lab); ++ ++ asm volatile inline goto ("" :::: lab); ++ asm volatile goto inline ("" :::: lab); ++ asm inline volatile goto ("" :::: lab); ++ asm inline goto volatile ("" :::: lab); ++ asm goto volatile inline ("" :::: lab); ++ asm goto inline volatile ("" :::: lab); + + /* Duplicates are not allowed. */ + asm goto volatile volatile ("" :::: lab); /* { dg-error "" } */ +@@ -16,6 +27,20 @@ f (void) + asm goto volatile goto ("" :::: lab); /* { dg-error "" } */ + asm volatile goto goto ("" :::: lab); /* { dg-error "" } */ + ++ asm inline volatile volatile ("" :::); /* { dg-error "" } */ ++ asm volatile inline volatile ("" :::); /* { dg-error "" } */ ++ asm volatile volatile inline ("" :::); /* { dg-error "" } */ ++ asm inline inline volatile ("" :::); /* { dg-error "" } */ ++ asm inline volatile inline ("" :::); /* { dg-error "" } */ ++ asm volatile inline inline ("" :::); /* { dg-error "" } */ ++ ++ asm goto inline inline ("" :::: lab); /* { dg-error "" } */ ++ asm inline goto inline ("" :::: lab); /* { dg-error "" } */ ++ asm inline inline goto ("" :::: lab); /* { dg-error "" } */ ++ asm goto goto inline ("" :::: lab); /* { dg-error "" } */ ++ asm goto inline goto ("" :::: lab); /* { dg-error "" } */ ++ asm inline goto goto ("" :::: lab); /* { dg-error "" } */ ++ + lab: + ; + } +diff --git a/gcc/tree-core.h b/gcc/tree-core.h +index 356330a..84f75e6 100644 +--- a/gcc/tree-core.h ++++ b/gcc/tree-core.h +@@ -1161,6 +1161,9 @@ struct GTY(()) tree_base { + OMP_CLAUSE_LINEAR_VARIABLE_STRIDE in + OMP_CLAUSE_LINEAR + ++ ASM_INLINE_P in ++ ASM_EXPR ++ + side_effects_flag: + + TREE_SIDE_EFFECTS in +diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c +index 7555dce..324c168 100644 +--- a/gcc/tree-inline.c ++++ b/gcc/tree-inline.c +@@ -4149,6 +4149,9 @@ estimate_num_insns (gimple *stmt, eni_weights *weights) + with very long asm statements. */ + if (count > 1000) + count = 1000; ++ /* If this asm is asm inline, count anything as minimum size. */ ++ if (gimple_asm_inline_p (as_a (stmt))) ++ count = MIN (1, count); + return MAX (1, count); + } + +diff --git a/gcc/tree.h b/gcc/tree.h +index 8e70314..324ef5b 100644 +--- a/gcc/tree.h ++++ b/gcc/tree.h +@@ -1263,6 +1263,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)) -- cgit v1.2.3