Tue Mar 5 00:17:16 UTC 201920190305001716

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.

18 files changed, 1814 insertions, 194 deletions

diff --git a/source/d/gcc/gcc.SlackBuild b/source/d/gcc/gcc.SlackBuild
index 6f93f767..d7443e81 100755
--- a/source/d/gcc/gcc.SlackBuild
+++ b/source/d/gcc/gcc.SlackBuild
@@ -57,7 +57,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 PKGNAM=gcc
 SRCVER=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
 VERSION=$(echo $SRCVER | cut -f 1 -d _)
-BUILD=${BUILD:-1}
+BUILD=${BUILD:-2}
 
 # How many jobs to run in parallel:
 NUMJOBS=${NUMJOBS:-" -j$(expr $(nproc) + 1) "}
@@ -166,6 +166,16 @@ cat $CWD/slack-desc.gcc-brig > $PKG9/install/slack-desc
   # Smite the fixincludes:
   zcat $CWD/gcc-no_fixincludes.diff.gz | patch -p1 --verbose --backup --suffix=.orig || exit 1
 
+  # Revert inline asm backport causing compile failures for "asm volatile":
+  zcat $CWD/patches/revert-asm-inline/8-8-c-Don-t-error-for-const-or-restrict-as-asm-qualifier.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/7-8-c-asm-Do-not-handle-any-asm-qualifiers-in-top-level-asm.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/6-8-c-c-asm-Use-nicer-error-for-const-and-restrict.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/5-8-c-c-asm-Use-nicer-error-for-duplicate-asm-qualifiers.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/4-8-c-c-asm-Write-the-asm-qualifier-loop-without-done-boolean.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/3-8-c-Delete-a-stray-line-in-asm-inline.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/2-8-asm-inline.patch.gz | patch -p1 -R --verbose || exit 1
+  zcat $CWD/patches/revert-asm-inline/1-8-asm-qualifiers-PR55681.patch.gz | patch -p1 -R --verbose || exit 1
+
   # Fix perms/owners:
   chown -R root:root .
   find . -perm 777 -exec chmod 755 {} \;
diff --git a/source/d/gcc/patches/revert-asm-inline/1-8-asm-qualifiers-PR55681.patch b/source/d/gcc/patches/revert-asm-inline/1-8-asm-qualifiers-PR55681.patch
new file mode 100644
index 00000000..1870b6ef
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/1-8-asm-qualifiers-PR55681.patch
@@ -0,0 +1,351 @@
+From patchwork Thu Dec 27 14:59:06 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [1/8] asm qualifiers (PR55681)
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13818
+Message-Id: <2ea395426865aeb7b02f16facf70908a852e7fbc.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:06 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+PR55681 observes that currently only one qualifier is allowed for
+inline asm, so that e.g. "volatile asm" is allowed, "const asm" is also
+okay (with a warning), but "const volatile asm" gives an error.  Also
+"goto" has to be last.
+
+This patch changes things so that only "asm-qualifiers" are allowed,
+that is "volatile" and "goto", in any combination, in any order, but
+without repetitions.
+
+2018-12-06  Segher Boessenkool  <segher@kernel.crashing.org>
+
+	PR inline-asm/55681
+	* doc/extend.texi (Basic Asm): Update grammar.
+	(Extended Asm): Update grammar.
+
+gcc/c/
+	PR inline-asm/55681
+	* c-parser.c (c_parser_asm_statement): Update grammar.  Allow any
+	combination of volatile and goto, in any order, without repetitions.
+
+gcc/cp/
+	PR inline-asm/55681
+	* parser.c (cp_parser_asm_definition): Update grammar.  Allow any
+	combination of volatile and goto, in any order, without repetitions.
+
+gcc/testsuite/
+	PR inline-asm/55681
+	* gcc.dg/asm-qual-1.c: Test that "const" and "restrict" are refused.
+	* gcc.dg/asm-qual-2.c: New test, test that asm-qualifiers are allowed
+	in any order, but that duplicates are not allowed.
+---
+ gcc/c/c-parser.c                  | 74 +++++++++++++++++++++----------------
+ gcc/cp/parser.c                   | 77 ++++++++++++++++++++++++++-------------
+ gcc/doc/extend.texi               |  8 ++--
+ gcc/testsuite/gcc.dg/asm-qual-1.c | 10 +++--
+ gcc/testsuite/gcc.dg/asm-qual-2.c | 21 +++++++++++
+ 5 files changed, 127 insertions(+), 63 deletions(-)
+ create mode 100644 gcc/testsuite/gcc.dg/asm-qual-2.c
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
+index 4772086..7ec53b3 100644
+--- a/gcc/c/c-parser.c
++++ b/gcc/c/c-parser.c
+@@ -6261,60 +6261,72 @@ 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 tag
++   statement with inputs, outputs, clobbers, and volatile and goto tag
+    allowed.
+ 
++   asm-qualifier:
++     volatile
++     goto
++
++   asm-qualifier-list:
++     asm-qualifier-list asm-qualifier
++     asm-qualifier
++
+    asm-statement:
+-     asm type-qualifier[opt] ( asm-argument ) ;
+-     asm type-qualifier[opt] goto ( asm-goto-argument ) ;
++     asm asm-qualifier-list[opt] ( asm-argument ) ;
+ 
+    asm-argument:
+      asm-string-literal
+      asm-string-literal : asm-operands[opt]
+      asm-string-literal : asm-operands[opt] : asm-operands[opt]
+-     asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers[opt]
+-
+-   asm-goto-argument:
++     asm-string-literal : asm-operands[opt] : asm-operands[opt] \
++       : asm-clobbers[opt]
+      asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
+        : asm-goto-operands
+ 
+-   Qualifiers other than volatile are accepted in the syntax but
+-   warned for.  */
++   The form with asm-goto-operands is valid if and only if the
++   asm-qualifier-list contains goto, and is the only allowed form in that case.
++   Duplicate asm-qualifiers are not allowed.  */
+ 
+ static tree
+ c_parser_asm_statement (c_parser *parser)
+ {
+   tree quals, str, outputs, inputs, clobbers, labels, ret;
+-  bool simple, is_goto;
++  bool simple, is_volatile, is_goto;
+   location_t asm_loc = c_parser_peek_token (parser)->location;
+   int section, nsections;
+ 
+   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
+   c_parser_consume_token (parser);
+-  if (c_parser_next_token_is_keyword (parser, RID_VOLATILE))
+-    {
+-      quals = c_parser_peek_token (parser)->value;
+-      c_parser_consume_token (parser);
+-    }
+-  else if (c_parser_next_token_is_keyword (parser, RID_CONST)
+-	   || c_parser_next_token_is_keyword (parser, RID_RESTRICT))
+-    {
+-      warning_at (c_parser_peek_token (parser)->location,
+-		  0,
+-		  "%E qualifier ignored on asm",
+-		  c_parser_peek_token (parser)->value);
+-      quals = NULL_TREE;
+-      c_parser_consume_token (parser);
+-    }
+-  else
+-    quals = NULL_TREE;
+ 
++  quals = NULL_TREE;
++  is_volatile = false;
+   is_goto = false;
+-  if (c_parser_next_token_is_keyword (parser, RID_GOTO))
+-    {
+-      c_parser_consume_token (parser);
+-      is_goto = true;
+-    }
++  for (bool done = false; !done; )
++    switch (c_parser_peek_token (parser)->keyword)
++      {
++      case RID_VOLATILE:
++	if (!is_volatile)
++	  {
++	    is_volatile = true;
++	    quals = c_parser_peek_token (parser)->value;
++	    c_parser_consume_token (parser);
++	  }
++	else
++	  done = true;
++	break;
++      case RID_GOTO:
++	if (!is_goto)
++	  {
++	    is_goto = true;
++	    c_parser_consume_token (parser);
++	  }
++	else
++	  done = true;
++	break;
++      default:
++	done = true;
++      }
+ 
+   /* ??? Follow the C++ parser rather than using the
+      lex_untranslated_string kludge.  */
+diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
+index 9907180..3bc5795 100644
+--- a/gcc/cp/parser.c
++++ b/gcc/cp/parser.c
+@@ -19067,22 +19067,34 @@ cp_parser_using_directive (cp_parser* parser)
+ 
+ /* Parse an asm-definition.
+ 
++  asm-qualifier:
++    volatile
++    goto
++
++  asm-qualifier-list:
++    asm-qualifier
++    asm-qualifier-list asm-qualifier
++
+    asm-definition:
+      asm ( string-literal ) ;
+ 
+    GNU Extension:
+ 
+    asm-definition:
+-     asm volatile [opt] ( string-literal ) ;
+-     asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
+-     asm volatile [opt] ( string-literal : asm-operand-list [opt]
+-			  : asm-operand-list [opt] ) ;
+-     asm volatile [opt] ( string-literal : asm-operand-list [opt]
+-			  : asm-operand-list [opt]
++     asm asm-qualifier-list [opt] ( string-literal ) ;
++     asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
++     asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
++				    : asm-operand-list [opt] ) ;
++     asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
++				    : asm-operand-list [opt]
+ 			  : asm-clobber-list [opt] ) ;
+-     asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
+-			       : asm-clobber-list [opt]
+-			       : asm-goto-list ) ;  */
++     asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
++				    : asm-clobber-list [opt]
++				    : asm-goto-list ) ;
++
++  The form with asm-goto-list is valid if and only if the asm-qualifier-list
++  contains goto, and is the only allowed form in that case.  No duplicates are
++  allowed in an asm-qualifier-list.  */
+ 
+ static void
+ cp_parser_asm_definition (cp_parser* parser)
+@@ -19111,23 +19123,36 @@ cp_parser_asm_definition (cp_parser* parser)
+     }
+ 
+   /* See if the next token is `volatile'.  */
+-  if (cp_parser_allow_gnu_extensions_p (parser)
+-      && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
+-    {
+-      /* Remember that we saw the `volatile' keyword.  */
+-      volatile_p = true;
+-      /* Consume the token.  */
+-      cp_lexer_consume_token (parser->lexer);
+-    }
+-  if (cp_parser_allow_gnu_extensions_p (parser)
+-      && parser->in_function_body
+-      && cp_lexer_next_token_is_keyword (parser->lexer, RID_GOTO))
+-    {
+-      /* Remember that we saw the `goto' keyword.  */
+-      goto_p = true;
+-      /* Consume the token.  */
+-      cp_lexer_consume_token (parser->lexer);
+-    }
++  if (cp_parser_allow_gnu_extensions_p (parser))
++    for (bool done = false; !done ; )
++      switch (cp_lexer_peek_token (parser->lexer)->keyword)
++	{
++	case RID_VOLATILE:
++	  if (!volatile_p)
++	    {
++	      /* Remember that we saw the `volatile' keyword.  */
++	      volatile_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)
++	    {
++	      /* Remember that we saw the `goto' keyword.  */
++	      goto_p = true;
++	      /* Consume the token.  */
++	      cp_lexer_consume_token (parser->lexer);
++	    }
++	  else
++	    done = true;
++	  break;
++	default:
++	  done = true;
++	}
++
+   /* Look for the opening `('.  */
+   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
+     return;
+diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
+index afde889..40b1989 100644
+--- a/gcc/doc/extend.texi
++++ b/gcc/doc/extend.texi
+@@ -8147,7 +8147,7 @@ for a C symbol, or to place a C variable in a specific register.
+ A basic @code{asm} statement has the following syntax:
+ 
+ @example
+-asm @r{[} volatile @r{]} ( @var{AssemblerInstructions} )
++asm @var{asm-qualifiers} ( @var{AssemblerInstructions} )
+ @end example
+ 
+ The @code{asm} keyword is a GNU extension.
+@@ -8275,17 +8275,19 @@ Extended @code{asm} syntax uses colons (@samp{:}) to delimit
+ the operand parameters after the assembler template:
+ 
+ @example
+-asm @r{[}volatile@r{]} ( @var{AssemblerTemplate} 
++asm @var{asm-qualifiers} ( @var{AssemblerTemplate} 
+                  : @var{OutputOperands} 
+                  @r{[} : @var{InputOperands}
+                  @r{[} : @var{Clobbers} @r{]} @r{]})
+ 
+-asm @r{[}volatile@r{]} goto ( @var{AssemblerTemplate} 
++asm @var{asm-qualifiers} ( @var{AssemblerTemplate} 
+                       : 
+                       : @var{InputOperands}
+                       : @var{Clobbers}
+                       : @var{GotoLabels})
+ @end example
++where in the last form, @var{asm-qualifiers} contains @code{goto} (and in the
++first form, not).
+ 
+ The @code{asm} keyword is a GNU extension.
+ When writing code that can be compiled with @option{-ansi} and the
+diff --git a/gcc/testsuite/gcc.dg/asm-qual-1.c b/gcc/testsuite/gcc.dg/asm-qual-1.c
+index 5ec9a29..cb37283 100644
+--- a/gcc/testsuite/gcc.dg/asm-qual-1.c
++++ b/gcc/testsuite/gcc.dg/asm-qual-1.c
+@@ -1,4 +1,4 @@
+-/* Test that qualifiers other than volatile are ignored on asm.  */
++/* Test that qualifiers other than volatile are disallowed on asm.  */
+ /* Origin: Joseph Myers <joseph@codesourcery.com> */
+ /* { dg-do compile } */
+ /* { dg-options "-std=gnu99" } */
+@@ -7,6 +7,10 @@ void
+ f (void)
+ {
+   asm volatile ("");
+-  asm const (""); /* { dg-warning "const qualifier ignored on asm" } */
+-  asm restrict (""); /* { dg-warning "restrict qualifier ignored on asm" } */
++
++  asm const (""); /* { dg-error {expected '\(' before 'const'} } */
++  /* { dg-error {expected identifier} {} {target *-*-*} .-1 } */
++
++  asm restrict (""); /* { dg-error {expected '\(' before 'restrict'} } */
++  /* { dg-error {expected identifier} {} {target *-*-*} .-1 } */
+ }
+diff --git a/gcc/testsuite/gcc.dg/asm-qual-2.c b/gcc/testsuite/gcc.dg/asm-qual-2.c
+new file mode 100644
+index 0000000..37df2ad
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/asm-qual-2.c
+@@ -0,0 +1,21 @@
++/* Test that qualifiers on asm are allowed in any order.  */
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++void
++f (void)
++{
++  asm volatile goto ("" :::: lab);
++  asm goto volatile ("" :::: lab);
++
++  /* Duplicates are not allowed.  */
++  asm goto volatile volatile ("" :::: lab);  /* { dg-error "" } */
++  asm volatile goto volatile ("" :::: lab);  /* { dg-error "" } */
++  asm volatile volatile goto ("" :::: lab);  /* { dg-error "" } */
++  asm goto goto volatile ("" :::: lab);  /* { dg-error "" } */
++  asm goto volatile goto ("" :::: lab);  /* { dg-error "" } */
++  asm volatile goto goto ("" :::: lab);  /* { dg-error "" } */
++
++lab:
++  ;
++}
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 00000000..9ffb77a8
--- /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 <segher@kernel.crashing.org>
+X-Patchwork-Id: 13820
+Message-Id: <420ded3dc643d9e1ee6239ca5a8d1942c69bfe76.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:07 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+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  <segher@kernel.crashing.org>
+
+	* 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 <gasm *> (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))
diff --git a/source/d/gcc/patches/revert-asm-inline/3-8-c-Delete-a-stray-line-in-asm-inline.patch b/source/d/gcc/patches/revert-asm-inline/3-8-c-Delete-a-stray-line-in-asm-inline.patch
new file mode 100644
index 00000000..043df146
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/3-8-c-Delete-a-stray-line-in-asm-inline.patch
@@ -0,0 +1,45 @@
+From patchwork Thu Dec 27 14:59:08 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [3/8] c: Delete a stray line in asm inline
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13819
+Message-Id: <35014fbfa36ce89dd26fdf43387416a907be4782.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:08 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+I noticed I accidentally copied a line too many from the "volatile"
+handling to the "inline" handling.  This fixes it.
+
+Tested on powerpc64-linux {-m32,-m64}; committing as trivial and obvious.
+
+Segher
+
+2018-12-08  Segher Boessenkool  <segher@kernel.crashing.org>
+
+gcc/c/
+	* c-parser (c_parser_asm_statement) [RID_INLINE]: Delete stray line
+	setting "quals".
+---
+ gcc/c/c-parser.c | 1 -
+ 1 file changed, 1 deletion(-)
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
+index 51cc2be..e45f70b 100644
+--- a/gcc/c/c-parser.c
++++ b/gcc/c/c-parser.c
+@@ -6321,7 +6321,6 @@ c_parser_asm_statement (c_parser *parser)
+ 	if (!is_inline)
+ 	  {
+ 	    is_inline = true;
+-	    quals = c_parser_peek_token (parser)->value;
+ 	    c_parser_consume_token (parser);
+ 	  }
+ 	else
diff --git a/source/d/gcc/patches/revert-asm-inline/4-8-c-c-asm-Write-the-asm-qualifier-loop-without-done-boolean.patch b/source/d/gcc/patches/revert-asm-inline/4-8-c-c-asm-Write-the-asm-qualifier-loop-without-done-boolean.patch
new file mode 100644
index 00000000..0c73f538
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/4-8-c-c-asm-Write-the-asm-qualifier-loop-without-done-boolean.patch
@@ -0,0 +1,194 @@
+From patchwork Thu Dec 27 14:59:09 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [4/8] c/c++, asm: Write the asm-qualifier loop without "done" boolean
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13821
+Message-Id: <5bbbd04162b8546d9c72da11cf33e6e61d1128d7.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:09 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+As suggested by Jason.
+
+Segher
+
+2018-12-10  Segher Boessenkool  <segher@kernel.crashing.org>
+
+c/
+	* c-parser.c (c_parser_asm_statement): Rewrite the loop to work without
+	"done" boolean variable.
+
+cp/
+	* parser.c (cp_parser_asm_definition): Rewrite the loop to work without
+	"done" boolean variable.
+---
+ gcc/c/c-parser.c | 65 +++++++++++++++++++++++++--------------------------
+ gcc/cp/parser.c  | 71 +++++++++++++++++++++++++-------------------------------
+ 2 files changed, 62 insertions(+), 74 deletions(-)
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
+index e45f70b..b632f68 100644
+--- a/gcc/c/c-parser.c
++++ b/gcc/c/c-parser.c
+@@ -6304,40 +6304,37 @@ c_parser_asm_statement (c_parser *parser)
+   is_volatile = false;
+   is_inline = false;
+   is_goto = false;
+-  for (bool done = false; !done; )
+-    switch (c_parser_peek_token (parser)->keyword)
+-      {
+-      case RID_VOLATILE:
+-	if (!is_volatile)
+-	  {
+-	    is_volatile = true;
+-	    quals = c_parser_peek_token (parser)->value;
+-	    c_parser_consume_token (parser);
+-	  }
+-	else
+-	  done = true;
+-	break;
+-      case RID_INLINE:
+-	if (!is_inline)
+-	  {
+-	    is_inline = true;
+-	    c_parser_consume_token (parser);
+-	  }
+-	else
+-	  done = true;
+-	break;
+-      case RID_GOTO:
+-	if (!is_goto)
+-	  {
+-	    is_goto = true;
+-	    c_parser_consume_token (parser);
+-	  }
+-	else
+-	  done = true;
+-	break;
+-      default:
+-	done = true;
+-      }
++  for (;;)
++    {
++      switch (c_parser_peek_token (parser)->keyword)
++	{
++	case RID_VOLATILE:
++	  if (is_volatile)
++	    break;
++	  is_volatile = true;
++	  quals = c_parser_peek_token (parser)->value;
++	  c_parser_consume_token (parser);
++	  continue;
++
++	case RID_INLINE:
++	  if (is_inline)
++	    break;
++	  is_inline = true;
++	  c_parser_consume_token (parser);
++	  continue;
++
++	case RID_GOTO:
++	  if (is_goto)
++	    break;
++	  is_goto = true;
++	  c_parser_consume_token (parser);
++	  continue;
++
++	default:
++	  break;
++	}
++      break;
++    }
+ 
+   /* ??? Follow the C++ parser rather than using the
+      lex_untranslated_string kludge.  */
+diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
+index 3fd9a02..7660565 100644
+--- a/gcc/cp/parser.c
++++ b/gcc/cp/parser.c
+@@ -19124,47 +19124,38 @@ cp_parser_asm_definition (cp_parser* parser)
+       cp_function_chain->invalid_constexpr = true;
+     }
+ 
+-  /* See if the next token is `volatile'.  */
++  /* Handle the asm-qualifier-list.  */
+   if (cp_parser_allow_gnu_extensions_p (parser))
+-    for (bool done = false; !done ; )
+-      switch (cp_lexer_peek_token (parser->lexer)->keyword)
+-	{
+-	case RID_VOLATILE:
+-	  if (!volatile_p)
+-	    {
+-	      /* Remember that we saw the `volatile' keyword.  */
+-	      volatile_p = true;
+-	      /* Consume the token.  */
+-	      cp_lexer_consume_token (parser->lexer);
+-	    }
+-	  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)
+-	    {
+-	      /* Remember that we saw the `goto' keyword.  */
+-	      goto_p = true;
+-	      /* Consume the token.  */
+-	      cp_lexer_consume_token (parser->lexer);
+-	    }
+-	  else
+-	    done = true;
+-	  break;
+-	default:
+-	  done = true;
+-	}
++    for (;;)
++      {
++	switch (cp_lexer_peek_token (parser->lexer)->keyword)
++	  {
++	  case RID_VOLATILE:
++	    if (volatile_p)
++	      break;
++	    volatile_p = true;
++	    cp_lexer_consume_token (parser->lexer);
++	    continue;
++
++	  case RID_INLINE:
++	    if (inline_p || !parser->in_function_body)
++	      break;
++	    inline_p = true;
++	    cp_lexer_consume_token (parser->lexer);
++	    continue;
++
++	  case RID_GOTO:
++	    if (goto_p || !parser->in_function_body)
++	      break;
++	    goto_p = true;
++	    cp_lexer_consume_token (parser->lexer);
++	    continue;
++
++	  default:
++	    break;
++	  }
++	break;
++      }
+ 
+   /* Look for the opening `('.  */
+   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
diff --git a/source/d/gcc/patches/revert-asm-inline/5-8-c-c-asm-Use-nicer-error-for-duplicate-asm-qualifiers.patch b/source/d/gcc/patches/revert-asm-inline/5-8-c-c-asm-Use-nicer-error-for-duplicate-asm-qualifiers.patch
new file mode 100644
index 00000000..6f8175c8
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/5-8-c-c-asm-Use-nicer-error-for-duplicate-asm-qualifiers.patch
@@ -0,0 +1,269 @@
+From patchwork Thu Dec 27 14:59:10 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [5/8] c/c++, asm: Use nicer error for duplicate asm qualifiers
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13822
+Message-Id: <30a12d359164450406601e125d128fc43af4d605.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:10 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+Also as suggested by Jason.
+
+Segher
+
+2018-12-10  Segher Boessenkool  <segher@kernel.crashing.org>
+
+c/
+	* c-parser.c (c_parser_asm_statement): Keep track of the location each
+	asm qualifier is first seen; use that to give nicer "duplicate asm
+	qualifier" messages.  Delete 'quals" variable, instead pass the
+	"is_volatile_ flag to build_asm_stmt directly.
+	* c-tree.h (build_asm_stmt): Make the first arg bool instead of tree.
+	* c-typeck.c (build_asm_stmt): Ditto; adjust.
+
+cp/
+	* parser.c (cp_parser_asm_definition): Rewrite the loop to work without
+	"done" boolean variable.
+	* parser.c (cp_parser_asm_definition): Keep track of the location each
+	asm qualifier is first seen; use that to give nicer "duplicate asm
+	qualifier" messages.
+---
+ gcc/c/c-parser.c | 57 ++++++++++++++++++++++++++++++++++++--------------------
+ gcc/c/c-tree.h   |  2 +-
+ gcc/c/c-typeck.c |  4 ++--
+ gcc/cp/parser.c  | 45 ++++++++++++++++++++++++++++++++------------
+ 4 files changed, 73 insertions(+), 35 deletions(-)
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
+index b632f68..ca04910 100644
+--- a/gcc/c/c-parser.c
++++ b/gcc/c/c-parser.c
+@@ -6292,41 +6292,54 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
+ static tree
+ c_parser_asm_statement (c_parser *parser)
+ {
+-  tree quals, str, outputs, inputs, clobbers, labels, ret;
+-  bool simple, is_volatile, is_inline, is_goto;
++  tree str, outputs, inputs, clobbers, labels, ret;
++  bool simple;
+   location_t asm_loc = c_parser_peek_token (parser)->location;
+   int section, nsections;
+ 
+   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
+   c_parser_consume_token (parser);
+ 
+-  quals = NULL_TREE;
+-  is_volatile = false;
+-  is_inline = false;
+-  is_goto = false;
++  /* Handle the asm-qualifier-list.  */
++  location_t volatile_loc = UNKNOWN_LOCATION;
++  location_t inline_loc = UNKNOWN_LOCATION;
++  location_t goto_loc = UNKNOWN_LOCATION;
+   for (;;)
+     {
+-      switch (c_parser_peek_token (parser)->keyword)
++      c_token *token = c_parser_peek_token (parser);
++      location_t loc = token->location;
++      switch (token->keyword)
+ 	{
+ 	case RID_VOLATILE:
+-	  if (is_volatile)
+-	    break;
+-	  is_volatile = true;
+-	  quals = c_parser_peek_token (parser)->value;
++	  if (volatile_loc)
++	    {
++	      error_at (loc, "duplicate asm qualifier %qE", token->value);
++	      inform (volatile_loc, "first seen here");
++	    }
++	  else
++	    volatile_loc = loc;
+ 	  c_parser_consume_token (parser);
+ 	  continue;
+ 
+ 	case RID_INLINE:
+-	  if (is_inline)
+-	    break;
+-	  is_inline = true;
++	  if (inline_loc)
++	    {
++	      error_at (loc, "duplicate asm qualifier %qE", token->value);
++	      inform (inline_loc, "first seen here");
++	    }
++	  else
++	    inline_loc = loc;
+ 	  c_parser_consume_token (parser);
+ 	  continue;
+ 
+ 	case RID_GOTO:
+-	  if (is_goto)
+-	    break;
+-	  is_goto = true;
++	  if (goto_loc)
++	    {
++	      error_at (loc, "duplicate asm qualifier %qE", token->value);
++	      inform (goto_loc, "first seen here");
++	    }
++	  else
++	    goto_loc = loc;
+ 	  c_parser_consume_token (parser);
+ 	  continue;
+ 
+@@ -6336,6 +6349,10 @@ c_parser_asm_statement (c_parser *parser)
+       break;
+     }
+ 
++  bool is_volatile = (volatile_loc != UNKNOWN_LOCATION);
++  bool is_inline = (inline_loc != UNKNOWN_LOCATION);
++  bool is_goto = (goto_loc != UNKNOWN_LOCATION);
++
+   /* ??? Follow the C++ parser rather than using the
+      lex_untranslated_string kludge.  */
+   parser->lex_untranslated_string = true;
+@@ -6410,9 +6427,9 @@ c_parser_asm_statement (c_parser *parser)
+   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
+     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,
+-					       is_inline));
++  ret = build_asm_stmt (is_volatile,
++			build_asm_expr (asm_loc, str, outputs, inputs,
++					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 7f34bdc..aa66aa2 100644
+--- a/gcc/c/c-tree.h
++++ b/gcc/c/c-tree.h
+@@ -679,7 +679,7 @@ 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,
+ 			    bool);
+-extern tree build_asm_stmt (tree, tree);
++extern tree build_asm_stmt (bool, tree);
+ extern int c_types_compatible_p (tree, tree);
+ extern tree c_begin_compound_stmt (bool);
+ extern tree c_end_compound_stmt (location_t, tree, bool);
+diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
+index 3ebb28e..7b90b5c 100644
+--- a/gcc/c/c-typeck.c
++++ b/gcc/c/c-typeck.c
+@@ -9979,9 +9979,9 @@ process_init_element (location_t loc, struct c_expr value, bool implicit,
+    (guaranteed to be 'volatile' or null) and ARGS (represented using
+    an ASM_EXPR node).  */
+ tree
+-build_asm_stmt (tree cv_qualifier, tree args)
++build_asm_stmt (bool is_volatile, tree args)
+ {
+-  if (!ASM_VOLATILE_P (args) && cv_qualifier)
++  if (is_volatile)
+     ASM_VOLATILE_P (args) = 1;
+   return add_stmt (args);
+ }
+diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
+index 7660565..44fdace 100644
+--- a/gcc/cp/parser.c
++++ b/gcc/cp/parser.c
+@@ -19106,12 +19106,9 @@ cp_parser_asm_definition (cp_parser* parser)
+   tree clobbers = NULL_TREE;
+   tree labels = NULL_TREE;
+   tree asm_stmt;
+-  bool volatile_p = false;
+   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;
+ 
+   /* Look for the `asm' keyword.  */
+@@ -19125,29 +19122,50 @@ cp_parser_asm_definition (cp_parser* parser)
+     }
+ 
+   /* Handle the asm-qualifier-list.  */
++  location_t volatile_loc = UNKNOWN_LOCATION;
++  location_t inline_loc = UNKNOWN_LOCATION;
++  location_t goto_loc = UNKNOWN_LOCATION;
+   if (cp_parser_allow_gnu_extensions_p (parser))
+     for (;;)
+       {
++	cp_token *token = cp_lexer_peek_token (parser->lexer);
++	location_t loc = token->location;
+ 	switch (cp_lexer_peek_token (parser->lexer)->keyword)
+ 	  {
+ 	  case RID_VOLATILE:
+-	    if (volatile_p)
+-	      break;
+-	    volatile_p = true;
++	    if (volatile_loc)
++	      {
++		error_at (loc, "duplicate asm qualifier %qT", token->u.value);
++		inform (volatile_loc, "first seen here");
++	      }
++	    else
++	      volatile_loc = loc;
+ 	    cp_lexer_consume_token (parser->lexer);
+ 	    continue;
+ 
+ 	  case RID_INLINE:
+-	    if (inline_p || !parser->in_function_body)
++	    if (!parser->in_function_body)
+ 	      break;
+-	    inline_p = true;
++	    if (inline_loc)
++	      {
++		error_at (loc, "duplicate asm qualifier %qT", token->u.value);
++		inform (inline_loc, "first seen here");
++	      }
++	    else
++	      inline_loc = loc;
+ 	    cp_lexer_consume_token (parser->lexer);
+ 	    continue;
+ 
+ 	  case RID_GOTO:
+-	    if (goto_p || !parser->in_function_body)
++	    if (!parser->in_function_body)
+ 	      break;
+-	    goto_p = true;
++	    if (goto_loc)
++	      {
++		error_at (loc, "duplicate asm qualifier %qT", token->u.value);
++		inform (goto_loc, "first seen here");
++	      }
++	    else
++	      goto_loc = loc;
+ 	    cp_lexer_consume_token (parser->lexer);
+ 	    continue;
+ 
+@@ -19157,6 +19175,10 @@ cp_parser_asm_definition (cp_parser* parser)
+ 	break;
+       }
+ 
++  bool volatile_p = (volatile_loc != UNKNOWN_LOCATION);
++  bool inline_p = (inline_loc != UNKNOWN_LOCATION);
++  bool goto_p = (goto_loc != UNKNOWN_LOCATION);
++
+   /* Look for the opening `('.  */
+   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
+     return;
+@@ -19248,8 +19270,7 @@ cp_parser_asm_definition (cp_parser* parser)
+ 					     CPP_CLOSE_PAREN))
+ 	    clobbers = cp_parser_asm_clobber_list (parser);
+ 	}
+-      else if (goto_p
+-	       && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
++      else if (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
+ 	/* The labels are coming next.  */
+ 	labels_p = true;
+ 
diff --git a/source/d/gcc/patches/revert-asm-inline/6-8-c-c-asm-Use-nicer-error-for-const-and-restrict.patch b/source/d/gcc/patches/revert-asm-inline/6-8-c-c-asm-Use-nicer-error-for-const-and-restrict.patch
new file mode 100644
index 00000000..0ee1c6b0
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/6-8-c-c-asm-Use-nicer-error-for-const-and-restrict.patch
@@ -0,0 +1,167 @@
+From patchwork Thu Dec 27 14:59:11 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [6/8] c/c++, asm: Use nicer error for const and restrict
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13823
+Message-Id: <a46fb9bafc04d68b39d57a57a8923e3667526f44.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:11 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+Not all qualifiers are asm qualifiers.  We can talk about that in a
+nicer way than just giving a generic parser error.
+
+This also adds two testcases for C++, that previously were for C only.
+
+2018-12-10  Segher Boessenkool  <segher@kernel.crashing.org>
+
+c/
+	* c-parser.c (c_parser_asm_statement) <RID_CONST, RID_RESTRICT>: Give
+	a more specific error message (instead of just falling through).
+
+cp/
+	* parser.c (cp_parser_asm_definition) <RID_CONST, RID_RESTRICT>: Give
+	a more specific error message (instead of just falling through).
+
+testsuite/
+	* g++.dg/asm-qual-1.C: New testcase.
+	* g++.dg/asm-qual-2.C: New testcase.
+	* gcc.dg/asm-qual-1.c: Update.
+---
+ gcc/c/c-parser.c                  |  6 +++++
+ gcc/cp/parser.c                   |  6 +++++
+ gcc/testsuite/g++.dg/asm-qual-1.C | 13 +++++++++++
+ gcc/testsuite/g++.dg/asm-qual-2.C | 46 +++++++++++++++++++++++++++++++++++++++
+ gcc/testsuite/gcc.dg/asm-qual-1.c |  6 ++---
+ 5 files changed, 73 insertions(+), 4 deletions(-)
+ create mode 100644 gcc/testsuite/g++.dg/asm-qual-1.C
+ create mode 100644 gcc/testsuite/g++.dg/asm-qual-2.C
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
+index ca04910..4baad62 100644
+--- a/gcc/c/c-parser.c
++++ b/gcc/c/c-parser.c
+@@ -6343,6 +6343,12 @@ c_parser_asm_statement (c_parser *parser)
+ 	  c_parser_consume_token (parser);
+ 	  continue;
+ 
++	case RID_CONST:
++	case RID_RESTRICT:
++	  error_at (loc, "%qE is not an asm qualifier", token->value);
++	  c_parser_consume_token (parser);
++	  continue;
++
+ 	default:
+ 	  break;
+ 	}
+diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
+index 44fdace..36d82b8 100644
+--- a/gcc/cp/parser.c
++++ b/gcc/cp/parser.c
+@@ -19169,6 +19169,12 @@ cp_parser_asm_definition (cp_parser* parser)
+ 	    cp_lexer_consume_token (parser->lexer);
+ 	    continue;
+ 
++	  case RID_CONST:
++	  case RID_RESTRICT:
++	    error_at (loc, "%qT is not an asm qualifier", token->u.value);
++	    cp_lexer_consume_token (parser->lexer);
++	    continue;
++
+ 	  default:
+ 	    break;
+ 	  }
+diff --git a/gcc/testsuite/g++.dg/asm-qual-1.C b/gcc/testsuite/g++.dg/asm-qual-1.C
+new file mode 100644
+index 0000000..3fba592
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/asm-qual-1.C
+@@ -0,0 +1,13 @@
++// Test that qualifiers other than volatile are disallowed on asm.
++// { dg-do compile }
++// { dg-options "-std=gnu++98" }
++
++void
++f ()
++{
++  asm volatile ("");
++
++  asm const (""); // { dg-error {'const' is not an asm qualifier} }
++
++  asm __restrict (""); // { dg-error {'__restrict' is not an asm qualifier} }
++}
+diff --git a/gcc/testsuite/g++.dg/asm-qual-2.C b/gcc/testsuite/g++.dg/asm-qual-2.C
+new file mode 100644
+index 0000000..52968bd
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/asm-qual-2.C
+@@ -0,0 +1,46 @@
++// Test that qualifiers on asm are allowed in any order.
++// { dg-do compile }
++// { dg-options "-std=c++98" }
++
++void
++f ()
++{
++  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 "" } */
++  asm volatile goto volatile ("" :::: lab);  /* { dg-error "" } */
++  asm volatile volatile goto ("" :::: lab);  /* { dg-error "" } */
++  asm goto goto volatile ("" :::: lab);  /* { dg-error "" } */
++  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/testsuite/gcc.dg/asm-qual-1.c b/gcc/testsuite/gcc.dg/asm-qual-1.c
+index cb37283..eff6b45 100644
+--- a/gcc/testsuite/gcc.dg/asm-qual-1.c
++++ b/gcc/testsuite/gcc.dg/asm-qual-1.c
+@@ -8,9 +8,7 @@ f (void)
+ {
+   asm volatile ("");
+ 
+-  asm const (""); /* { dg-error {expected '\(' before 'const'} } */
+-  /* { dg-error {expected identifier} {} {target *-*-*} .-1 } */
++  asm const (""); /* { dg-error {'const' is not an asm qualifier} } */
+ 
+-  asm restrict (""); /* { dg-error {expected '\(' before 'restrict'} } */
+-  /* { dg-error {expected identifier} {} {target *-*-*} .-1 } */
++  asm restrict (""); /* { dg-error {'restrict' is not an asm qualifier} } */
+ }
diff --git a/source/d/gcc/patches/revert-asm-inline/7-8-c-asm-Do-not-handle-any-asm-qualifiers-in-top-level-asm.patch b/source/d/gcc/patches/revert-asm-inline/7-8-c-asm-Do-not-handle-any-asm-qualifiers-in-top-level-asm.patch
new file mode 100644
index 00000000..e124f7c2
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/7-8-c-asm-Do-not-handle-any-asm-qualifiers-in-top-level-asm.patch
@@ -0,0 +1,103 @@
+From patchwork Thu Dec 27 14:59:12 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [7/8] c++, asm: Do not handle any asm-qualifiers in top-level asm
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13824
+Message-Id: <7d103b408f9dda95b9d9f5182281ae6bb3947716.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:12 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+Previously, "volatile" was allowed.  Changing this simplifies the code,
+makes things more regular, and makes the C and C++ frontends handle
+this the same way.
+
+2018-12-10  Segher Boessenkool  <segher@kernel.crashing.org>
+
+cp/
+	* parser.c (cp_parser_asm_definition): Do not allow any asm qualifiers
+	on top-level asm.
+
+testsuite/
+	* g++.dg/asm-qual-3.C: New testcase.
+	* gcc.dg/asm-qual-3.c: New testcase.
+---
+ gcc/cp/parser.c                   |  7 ++-----
+ gcc/testsuite/g++.dg/asm-qual-3.C | 12 ++++++++++++
+ gcc/testsuite/gcc.dg/asm-qual-3.c |  9 +++++++++
+ 3 files changed, 23 insertions(+), 5 deletions(-)
+ create mode 100644 gcc/testsuite/g++.dg/asm-qual-3.C
+ create mode 100644 gcc/testsuite/gcc.dg/asm-qual-3.c
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
+index 36d82b8..afc7b96 100644
+--- a/gcc/cp/parser.c
++++ b/gcc/cp/parser.c
+@@ -19125,7 +19125,8 @@ cp_parser_asm_definition (cp_parser* parser)
+   location_t volatile_loc = UNKNOWN_LOCATION;
+   location_t inline_loc = UNKNOWN_LOCATION;
+   location_t goto_loc = UNKNOWN_LOCATION;
+-  if (cp_parser_allow_gnu_extensions_p (parser))
++
++  if (cp_parser_allow_gnu_extensions_p (parser) && parser->in_function_body)
+     for (;;)
+       {
+ 	cp_token *token = cp_lexer_peek_token (parser->lexer);
+@@ -19144,8 +19145,6 @@ cp_parser_asm_definition (cp_parser* parser)
+ 	    continue;
+ 
+ 	  case RID_INLINE:
+-	    if (!parser->in_function_body)
+-	      break;
+ 	    if (inline_loc)
+ 	      {
+ 		error_at (loc, "duplicate asm qualifier %qT", token->u.value);
+@@ -19157,8 +19156,6 @@ cp_parser_asm_definition (cp_parser* parser)
+ 	    continue;
+ 
+ 	  case RID_GOTO:
+-	    if (!parser->in_function_body)
+-	      break;
+ 	    if (goto_loc)
+ 	      {
+ 		error_at (loc, "duplicate asm qualifier %qT", token->u.value);
+diff --git a/gcc/testsuite/g++.dg/asm-qual-3.C b/gcc/testsuite/g++.dg/asm-qual-3.C
+new file mode 100644
+index 0000000..95c9b57
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/asm-qual-3.C
+@@ -0,0 +1,12 @@
++// Test that asm-qualifiers are not allowed on toplevel asm.
++// { dg-do compile }
++// { dg-options "-std=gnu++98" }
++
++asm const ("");    // { dg-error {expected '\(' before 'const'} }
++asm volatile (""); // { dg-error {expected '\(' before 'volatile'} }
++asm restrict (""); // { dg-error {expected '\(' before 'restrict'} }
++asm inline ("");   // { dg-error {expected '\(' before 'inline'} }
++asm goto ("");     // { dg-error {expected '\(' before 'goto'} }
++
++// There are many other things wrong with this code, so:
++// { dg-excess-errors "" }
+diff --git a/gcc/testsuite/gcc.dg/asm-qual-3.c b/gcc/testsuite/gcc.dg/asm-qual-3.c
+new file mode 100644
+index 0000000..f85d8bf
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/asm-qual-3.c
+@@ -0,0 +1,9 @@
++/* Test that asm-qualifiers are not allowed on toplevel asm.  */
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++asm const ("");    /* { dg-error {expected '\(' before 'const'} } */
++asm volatile (""); /* { dg-error {expected '\(' before 'volatile'} } */
++asm restrict (""); /* { dg-error {expected '\(' before 'restrict'} } */
++asm inline ("");   /* { dg-error {expected '\(' before 'inline'} } */
++asm goto ("");     /* { dg-error {expected '\(' before 'goto'} } */
diff --git a/source/d/gcc/patches/revert-asm-inline/8-8-c-Don-t-error-for-const-or-restrict-as-asm-qualifier.patch b/source/d/gcc/patches/revert-asm-inline/8-8-c-Don-t-error-for-const-or-restrict-as-asm-qualifier.patch
new file mode 100644
index 00000000..2b75e3f1
--- /dev/null
+++ b/source/d/gcc/patches/revert-asm-inline/8-8-c-Don-t-error-for-const-or-restrict-as-asm-qualifier.patch
@@ -0,0 +1,58 @@
+From patchwork Thu Dec 27 14:59:13 2018
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Subject: [8/8] c: Don't error for const or restrict as asm-qualifier
+X-Patchwork-Submitter: Segher Boessenkool <segher@kernel.crashing.org>
+X-Patchwork-Id: 13825
+Message-Id: <f0e4c2f3f89d0587a2ae547432d9a94bca9d06ff.1545922222.git.segher@kernel.crashing.org>
+To: gcc-patches@gcc.gnu.org
+Cc: Segher Boessenkool <segher@kernel.crashing.org>
+Date: Thu, 27 Dec 2018 14:59:13 +0000
+From: Segher Boessenkool <segher@kernel.crashing.org>
+List-Id: <gcc-patches.gcc.gnu.org>
+
+2018-12-27  Segher Boessenkool  <segher@kernel.crashing.org>
+
+c/
+	* c-parser.c (c_parser_asm_statement): Output a warning instead of an
+	error for const and restrict.
+
+testsuite/
+	* gcc.dg/asm-qual-1.c: Adjust.
+
+---
+ gcc/c/c-parser.c                  | 2 +-
+ gcc/testsuite/gcc.dg/asm-qual-1.c | 4 ++--
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+
+-- 
+1.8.3.1
+
+diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
+index 4baad62..a960169 100644
+--- a/gcc/c/c-parser.c
++++ b/gcc/c/c-parser.c
+@@ -6345,7 +6345,7 @@ c_parser_asm_statement (c_parser *parser)
+ 
+ 	case RID_CONST:
+ 	case RID_RESTRICT:
+-	  error_at (loc, "%qE is not an asm qualifier", token->value);
++	  warning_at (loc, 0, "%qE is not an asm qualifier", token->value);
+ 	  c_parser_consume_token (parser);
+ 	  continue;
+ 
+diff --git a/gcc/testsuite/gcc.dg/asm-qual-1.c b/gcc/testsuite/gcc.dg/asm-qual-1.c
+index eff6b45..4982a6b 100644
+--- a/gcc/testsuite/gcc.dg/asm-qual-1.c
++++ b/gcc/testsuite/gcc.dg/asm-qual-1.c
+@@ -8,7 +8,7 @@ f (void)
+ {
+   asm volatile ("");
+ 
+-  asm const (""); /* { dg-error {'const' is not an asm qualifier} } */
++  asm const (""); /* { dg-warning {'const' is not an asm qualifier} } */
+ 
+-  asm restrict (""); /* { dg-error {'restrict' is not an asm qualifier} } */
++  asm restrict (""); /* { dg-warning {'restrict' is not an asm qualifier} } */
+ }
diff --git a/source/l/FTBFSlog b/source/l/FTBFSlog
index f92acde6..0b04c0ce 100644
--- a/source/l/FTBFSlog
+++ b/source/l/FTBFSlog
@@ -1,3 +1,7 @@
+Mon Mar  4 23:07:37 UTC 2019
+  qt: tested and found to compile with newly patched gcc.
+  Thanks to nobodino.
++--------------------------+
 Sun Feb 10 20:16:20 UTC 2019
   gtkspell: regenerate build to fix newer gtk-doc dropping gtkdoc-mktmpl.
   Thanks to nobodino.
diff --git a/source/l/gc/gc.SlackBuild b/source/l/gc/gc.SlackBuild
index 3fdd6275..07a46488 100755
--- a/source/l/gc/gc.SlackBuild
+++ b/source/l/gc/gc.SlackBuild
@@ -27,7 +27,7 @@ PKGNAM=gc
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
 BUILD=${BUILD:-1}
 
-LAO_VERSION="7.6.8"	# libatomic_ops version
+LAO_VERSION="7.6.10"	# libatomic_ops version
 
 # Automatically determine the architecture we're building on:
 if [ -z "$ARCH" ]; then
diff --git a/source/l/glib2/glib2.SlackBuild b/source/l/glib2/glib2.SlackBuild
index 4998e415..66c5f11c 100755
--- a/source/l/glib2/glib2.SlackBuild
+++ b/source/l/glib2/glib2.SlackBuild
@@ -80,26 +80,40 @@ find . \
 # Get the local timezone link from /etc/localtime-copied-from:
 zcat $CWD/glib2.slackware.localtime.diff.gz | patch -p1 --verbose || exit 1
 
-if [ ! -r configure ]; then
-  NOCONFIGURE=1 ./autogen.sh
-fi
-
-CFLAGS="$SLKCFLAGS" \
-./configure \
+# Configure, build, and install:
+export CFLAGS="$SLKCFLAGS"
+export CXXFLAGS="$SLKCFLAGS"
+mkdir meson-build
+cd meson-build
+meson setup \
   --prefix=/usr \
-  --libdir=/usr/lib${LIBDIRSUFFIX} \
-  --sysconfdir=/etc \
+  --libdir=lib${LIBDIRSUFFIX} \
+  --libexecdir=/usr/libexec \
+  --bindir=/usr/bin \
+  --sbindir=/usr/sbin \
+  --includedir=/usr/include \
+  --datadir=/usr/share \
   --mandir=/usr/man \
-  --enable-gtk-doc \
-  --disable-libelf \
-  --build=$ARCH-slackware-linux || exit 1
-
-make $NUMJOBS || make || exit 1
-make install DESTDIR=$PKG || exit 1
+  --sysconfdir=/etc \
+  --localstatedir=/var \
+  --buildtype=release \
+  -Dselinux=disabled \
+  -Dfam=true \
+  -Dman=true \
+  -Dgtk_doc=true \
+  -Dinstalled_tests=false \
+  .. || exit 1
+  ninja || exit 1
+  DESTDIR=$PKG ninja install || exit 1
+cd ..
 
 # Don't ship .la files:
 rm -f $PKG/{,usr/}lib${LIBDIRSUFFIX}/*.la
 
+# Since meson isn't listening to options:
+rm -rf $PKG/usr/libexec/installed-tests
+rmdir $PKG/usr/libexec
+
 # Install profile scripts:
 mkdir -p $PKG/etc/profile.d/
 cp -a $CWD/libglib2.{csh,sh} $PKG/etc/profile.d/
diff --git a/source/l/glib2/glib2.SlackBuild.meson b/source/l/glib2/glib2.SlackBuild.meson
deleted file mode 100755
index 6d035048..00000000
--- a/source/l/glib2/glib2.SlackBuild.meson
+++ /dev/null
@@ -1,172 +0,0 @@
-#!/bin/bash
-
-# Copyright 2008, 2009, 2010, 2011, 2015, 2017, 2018  Patrick J. Volkerding, Sebeka, MN, USA
-# All rights reserved.
-#
-# Redistribution and use of this script, with or without modification, is
-# permitted provided that the following conditions are met:
-#
-# 1. Redistributions of this script must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-#
-#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-#  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-#  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
-#  EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-cd $(dirname $0) ; CWD=$(pwd)
-
-PKGNAM=glib2
-VERSION=${VERSION:-$(echo glib-*.tar.?z* | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-1}
-
-NUMJOBS=${NUMJOBS:-" -j$(expr $(nproc) + 1) "}
-
-# Automatically determine the architecture we're building on:
-if [ -z "$ARCH" ]; then
-  case "$( uname -m )" in
-    i?86) export ARCH=i586 ;;
-    arm*) export ARCH=arm ;;
-    # Unless $ARCH is already set, use uname -m for all other archs:
-       *) export ARCH=$( uname -m ) ;;
-  esac
-fi
-
-# If the variable PRINT_PACKAGE_NAME is set, then this script will report what
-# the name of the created package would be, and then exit. This information
-# could be useful to other scripts.
-if [ ! -z "${PRINT_PACKAGE_NAME}" ]; then
-  echo "$PKGNAM-$VERSION-$ARCH-$BUILD.txz"
-  exit 0
-fi
-
-TMP=${TMP:-/tmp}
-PKG=$TMP/package-glib2
-
-if [ "$ARCH" = "i586" ]; then
-  SLKCFLAGS="-O2 -march=i586 -mtune=i686"
-  LIBDIRSUFFIX=""
-elif [ "$ARCH" = "s390" ]; then
-  SLKCFLAGS="-O2"
-  LIBDIRSUFFIX=""
-elif [ "$ARCH" = "x86_64" ]; then
-  SLKCFLAGS="-O2 -fPIC"
-  LIBDIRSUFFIX="64"
-else
-  SLKCFLAGS="-O2"
-  LIBDIRSUFFIX=""
-fi
-
-rm -rf $PKG
-mkdir -p $TMP $PKG/usr
-cd $TMP
-rm -rf glib-$VERSION
-tar xvf $CWD/glib-$VERSION.tar.?z* || exit 1
-cd glib-$VERSION || exit 1
-
-chown -R root:root .
-find . \
- \( -perm 777 -o -perm 775 -o -perm 711 -o -perm 555 -o -perm 511 \) \
- -exec chmod 755 {} \; -o \
- \( -perm 666 -o -perm 664 -o -perm 600 -o -perm 444 -o -perm 440 -o -perm 400 \) \
- -exec chmod 644 {} \;
-
-# Get the local timezone link from /etc/localtime-copied-from:
-zcat $CWD/glib2.slackware.localtime.diff.gz | patch -p1 --verbose || exit 1
-
-# Configure, build, and install:
-export CFLAGS="$SLKCFLAGS"
-export CXXFLAGS="$SLKCFLAGS"
-mkdir meson-build
-cd meson-build
-meson setup \
-  --prefix=/usr \
-  --libdir=lib${LIBDIRSUFFIX} \
-  --libexecdir=/usr/libexec \
-  --bindir=/usr/bin \
-  --sbindir=/usr/sbin \
-  --includedir=/usr/include \
-  --datadir=/usr/share \
-  --mandir=/usr/man \
-  --sysconfdir=/etc \
-  --localstatedir=/var \
-  --buildtype=release \
-  -Dselinux=false \
-  -Dfam=true \
-  -Dman=true \
-  -Dgtk_doc=true \
-  .. || exit 1
-  ninja || exit 1
-  DESTDIR=$PKG ninja install || exit 1
-cd ..
-
-# Don't ship .la files:
-rm -f $PKG/{,usr/}lib${LIBDIRSUFFIX}/*.la
-
-# Install profile scripts:
-mkdir -p $PKG/etc/profile.d/
-cp -a $CWD/libglib2.{csh,sh} $PKG/etc/profile.d/
-chown root:root $PKG/etc/profile.d/*
-chmod 755 $PKG/etc/profile.d/*
-mv $PKG/etc/profile.d/libglib2.csh $PKG/etc/profile.d/libglib2.csh.new
-mv $PKG/etc/profile.d/libglib2.sh $PKG/etc/profile.d/libglib2.sh.new
-
-find $PKG | xargs file | grep -e "executable" -e "shared object" \
-  | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
-
-# Compress and link manpages, if any:
-if [ -d $PKG/usr/man ]; then
-  ( cd $PKG/usr/man
-    for manpagedir in $(find . -type d -name "man*") ; do
-      ( cd $manpagedir
-        for eachpage in $( find . -type l -maxdepth 1) ; do
-          ln -s $( readlink $eachpage ).gz $eachpage.gz
-          rm $eachpage
-        done
-        gzip -9 *.?
-      )
-    done
-  )
-fi
-
-mkdir -p $PKG/usr/doc/glib-$VERSION
-cp -a \
-  AUTHORS COPYING* NEWS README* \
-  $PKG/usr/doc/glib-$VERSION
-  rm -f $PKG/usr/doc/glib-$VERSION/README.{in,win32}
-
-# Make links to the documentation in /usr/share/gtk-doc/:
-( cd $PKG/usr/doc/glib-$VERSION
-  for dir in $PKG/usr/share/gtk-doc/html/* ; do
-    ln -s /usr/share/gtk-doc/html/$(basename $dir) .
-  done
-)
-
-# If there's a ChangeLog, installing at least part of the recent history
-# is useful, but don't let it get totally out of control:
-if [ -r ChangeLog ]; then
-  DOCSDIR=$(echo $PKG/usr/doc/*-$VERSION)
-  cat ChangeLog | head -n 1000 > $DOCSDIR/ChangeLog
-  touch -r ChangeLog $DOCSDIR/ChangeLog
-fi
-
-# Trim down bloated NEWS file:
-if [ -r NEWS ]; then
-  DOCSDIR=$(echo $PKG/usr/doc/*-$VERSION)
-  cat NEWS | head -n 1000 > $DOCSDIR/NEWS
-  touch -r NEWS $DOCSDIR/NEWS
-fi
-
-mkdir -p $PKG/install
-cat $CWD/slack-desc > $PKG/install/slack-desc
-zcat $CWD/doinst.sh.gz | sed "s,@LIBDIR@,/usr/lib${LIBDIRSUFFIX}," > $PKG/install/doinst.sh
-
-cd $PKG
-/sbin/makepkg -l y -c n --prepend $TMP/glib2-$VERSION-$ARCH-$BUILD.txz
-
diff --git a/source/n/postfix/doinst.sh b/source/n/postfix/doinst.sh
index e67f7ea1..3ee35f30 100644
--- a/source/n/postfix/doinst.sh
+++ b/source/n/postfix/doinst.sh
@@ -67,10 +67,10 @@ fi
 # existing config files (/etc/postfix/{main,master}.cf).  It won't hurt
 # anything on a new install.
 if [ -x usr/sbin/postfix ]; then
-  chroot . /usr/sbin/postfix upgrade-configuration
+  chroot . /usr/sbin/postfix upgrade-configuration 1> /dev/null 2> /dev/null
 fi
 
 # Process /etc/aliases into a database:
 if [ -x usr/bin/newaliases ]; then
-  chroot . /usr/bin/newaliases
+  chroot . /usr/bin/newaliases 1> /dev/null 2> /dev/null
 fi
diff --git a/source/n/postfix/postfix.SlackBuild b/source/n/postfix/postfix.SlackBuild
index 1227f291..e82b1d43 100755
--- a/source/n/postfix/postfix.SlackBuild
+++ b/source/n/postfix/postfix.SlackBuild
@@ -28,7 +28,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=postfix
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-1}
+BUILD=${BUILD:-2}
 
 if [ -z "$ARCH" ]; then
   case "$( uname -m )" in
diff --git a/source/x/x11/build/xinit b/source/x/x11/build/xinit
index 0cfbf088..d00491fd 100644
--- a/source/x/x11/build/xinit
+++ b/source/x/x11/build/xinit
@@ -1 +1 @@
-2
+1
diff --git a/source/x/x11/build/xlogo b/source/x/x11/build/xlogo
index 00750edc..d00491fd 100644
--- a/source/x/x11/build/xlogo
+++ b/source/x/x11/build/xlogo
@@ -1 +1 @@
-3
+1
diff --git a/source/x/x11/build/xmore b/source/x/x11/build/xmore
index 00750edc..d00491fd 100644
--- a/source/x/x11/build/xmore
+++ b/source/x/x11/build/xmore
@@ -1 +1 @@
-3
+1