Merge from trunk revision f3e9c98a9f40fc24bb4ecef6aaa94ff799c8d587.

50 files changed, 1371 insertions, 15 deletions

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 7ed0052..5e6b536 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,214 @@
+2021-03-16  Christophe Lyon  <christophe.lyon@linaro.org>
+
+	PR target/99542
+	* gcc.dg/declare-simd.c (fn2): Expect a warning only under lp64.
+
+2021-03-16  Jason Merrill  <jason@redhat.com>
+
+	* g++.dg/cpp2a/nontype-float1.C: New test.
+
+2021-03-16  Segher Boessenkool  <segher@kernel.crashing.org>
+
+	PR target/98092
+	PR target/98092
+	* gcc.target/powerpc/pr98092.c: New.
+
+2021-03-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99600
+	* gcc.target/i386/pr99600.c: New test.
+
+2021-03-16  Martin Liska  <mliska@suse.cz>
+	    Jason Merrill  <jason@redhat.com>
+
+	PR c++/99108
+	* g++.target/i386/pr99108.C: New test.
+
+2021-03-16  Martin Liska  <mliska@suse.cz>
+
+	PR target/99592
+	* gcc.target/arm/pr99592.c: New test.
+
+2021-03-16  Ilya Leoshkevich  <iii@linux.ibm.com>
+
+	* gcc.target/s390/vector/long-double-asm-fprvrmem.c: New test.
+
+2021-03-16  Nathan Sidwell  <nathan@acm.org>
+
+	PR c++/99496
+	* g++.dg/modules/pr99496_a.H: New.
+	* g++.dg/modules/pr99496_b.C: New.
+
+2021-03-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99563
+	* gcc.target/i386/avx-pr99563.c: New test.
+
+2021-03-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99542
+	* gcc.dg/gomp/pr99542.c: New test.
+	* gcc.dg/gomp/pr59669-2.c (bar): Don't expect a warning on aarch64.
+	* gcc.dg/gomp/simd-clones-2.c (setArray): Likewise.
+	* g++.dg/vect/simd-clone-7.cc (bar): Likewise.
+	* g++.dg/gomp/declare-simd-1.C (f37): Expect a different warning
+	on aarch64.
+	* gcc.dg/declare-simd.c (fn2): Expect a new warning on aarch64.
+
+2021-03-15  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/99601
+	* g++.dg/modules/builtin-3_a.C: Fix target selector syntax errors.
+	* g++.dg/modules/builtin-3_b.C: Likewise.
+
+2021-03-15  Nathan Sidwell  <nathan@acm.org>
+
+	PR c++/99601
+	* g++.dg/modules/builtin-3_a.C: Fix lp64 x86 detection.
+	* g++.dg/modules/builtin-3_b.C: Fix lp64 x86 detection.
+
+2021-03-15  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR c++/99047
+	* g++.dg/coroutines/pr99047.C: New test.
+
+2021-03-15  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR c++/98704
+	* g++.dg/coroutines/torture/pr98704.C: New test.
+
+2021-03-15  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR c++/98480
+	* g++.dg/coroutines/pr98480.C: New test.
+	* g++.dg/coroutines/torture/co-await-24-for-init.C: New test.
+	* g++.dg/coroutines/torture/co-await-25-for-condition.C: New test.
+	* g++.dg/coroutines/torture/co-await-26-for-iteration-expr.C: New test.
+
+2021-03-15  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR c++/96749
+	* g++.dg/coroutines/pr96749-1.C: New test.
+	* g++.dg/coroutines/pr96749-2.C: New test.
+
+2021-03-15  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/98834
+	* g++.dg/opt/pr98834.C: New testcase.
+
+2021-03-15  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/99345
+	* gfortran.dg/do_check_16.f90: New test.
+	* gfortran.dg/do_check_17.f90: New test.
+
+2021-03-15  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/99545
+	* gfortran.dg/pr99545.f90: New test.
+
+2021-03-15  David Edelsohn  <dje.gcc@gmail.com>
+
+	* gcc.target/powerpc/pr99492.c: Fix typo.
+
+2021-03-14  Harald Anlauf  <anlauf@gmx.de>
+	    Paul Thomas  <pault@gcc.gnu.org>
+
+	* gfortran.dg/pr99112.f90: New test.
+
+2021-03-13  Martin Sebor  <msebor@redhat.com>
+
+	PR tree-optimization/99489
+	* gcc.dg/Wstringop-truncation-9.c: New test.
+
+2021-03-13  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/99125
+	* gfortran.dg/alloc_deferred_comp_1.f90: New test.
+
+2021-03-13  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/99544
+	* gcc.dg/gomp/pr99544.c: New test.
+
+2021-03-12  Nathan Sidwell  <nathan@acm.org>
+
+	PR c++/99238
+	* g++.dg/modules/pr99238.h: New.
+	* g++.dg/modules/pr99238_a.H: New.
+	* g++.dg/modules/pr99238_b.H: New.
+
+2021-03-12  Tobias Burnus  <tobias@codesourcery.com>
+
+	PR fortran/99514
+	* gfortran.dg/gomp/threadprivate-1.f90: New test.
+
+2021-03-12  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/99321
+	* gcc.target/i386/avx512vl-pr99321-2.c: New test.
+
+2021-03-12  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/99507
+	* g++.dg/cpp2a/consteval19.C: New test.
+
+2021-03-11  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/96374
+	* gcc.dg/analyzer/dot-output.c: Add -fdump-analyzer-feasibility
+	to options.
+	* gcc.dg/analyzer/feasibility-1.c (test_6): Remove xfail.
+	(test_7): New.
+	* gcc.dg/analyzer/pr93355-localealias-feasibility-2.c: Remove xfail.
+	* gcc.dg/analyzer/pr93355-localealias-feasibility-3.c: Remove xfails.
+	* gcc.dg/analyzer/pr93355-localealias-feasibility.c: Remove
+	-fno-analyzer-feasibility from options.
+	* gcc.dg/analyzer/pr93355-localealias.c: Likewise.
+	* gcc.dg/analyzer/unknown-fns-4.c: Remove xfail.
+
+2021-03-11  Nathan Sidwell  <nathan@acm.org>
+
+	PR c++/99248
+	* g++.dg/modules/pr99248.h: New.
+	* g++.dg/modules/pr99248_a.H: New.
+	* g++.dg/modules/pr99248_b.H: New.
+
+2021-03-11  Nathan Sidwell  <nathan@acm.org>
+
+	PR c++/99528
+	* g++.dg/modules/pr99528.h: New.
+	* g++.dg/modules/pr99528_a.H: New.
+	* g++.dg/modules/pr99528_b.H: New.
+	* g++.dg/modules/pr99528_c.C: New.
+
+2021-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR testsuite/98245
+	* gcc.dg/vect/bb-slp-46.c: Scan for the scalar compute
+	instead of verifying the total number of adds.
+
+2021-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR testsuite/97494
+	* gcc.dg/vect/pr97428.c: XFAIL on !vect_hw_misalign.
+
+2021-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR testsuite/97494
+	* gcc.dg/vect/vect-complex-5.c: XFAIL on !vect_hw_misalign.
+
+2021-03-11  Richard Biener  <rguenther@suse.de>
+
+	PR testsuite/97494
+	* gcc.dg/vect/slp-21.c: Adjust for powerpc64*-*-*.
+
+2021-03-11  Jakub Jelinek  <jakub@redhat.com>
+
+	PR ipa/99517
+	* gcc.target/i386/avx2-pr99517-1.c: New test.
+	* gcc.target/i386/avx2-pr99517-2.c: New test.
+
 2021-03-10  David Edelsohn  <dje.gcc@gmail.com>
 
 	PR target/99492
diff --git a/gcc/testsuite/c-c++-common/asan/memcmp-1.c b/gcc/testsuite/c-c++-common/asan/memcmp-1.c
index 0403ad7..0d08c09 100644
--- a/gcc/testsuite/c-c++-common/asan/memcmp-1.c
+++ b/gcc/testsuite/c-c++-common/asan/memcmp-1.c
@@ -1,5 +1,6 @@
 /* { dg-do run } */
 /* { dg-options "-fno-builtin-memcmp" } */
+/* { dg-additional-options "-D_FORTIFY_SOURCE=0 -gdwarf-3" { target *-*-darwin* } } */
 /* { dg-shouldfail "asan" } */
 
 #include <string.h>
@@ -16,5 +17,8 @@ main ()
 }
 
 /* { dg-output "ERROR: AddressSanitizer: stack-buffer-overflow.*(\n|\r\n|\r)" } */
-/* { dg-output "    #\[1-9\] 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)memcmp|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
-/* { dg-output "    #\[2-9\] 0x\[0-9a-f\]+ +(in _*main|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
+/* { dg-output "    #\[1-9\] 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)memcmp|\[(\])\[^\n\r]*(\n|\r\n|\r)" { target { ! *-*-darwin* } } } */
+/* { dg-output "    #\[2-9\] 0x\[0-9a-f\]+ +(in _*main|\[(\])\[^\n\r]*(\n|\r\n|\r)" { target { ! *-*-darwin* } } } */
+
+/* { dg-output "    #\[0-9\] 0x\[0-9a-f\]+ +(in MemcmpInterceptorCommon|\[(\])\[^\n\r]*(\n|\r\n|\r)" { target *-*-darwin* } } */
+/* { dg-output "    #\[1-9\] 0x\[0-9a-f\]+ +(in wrap_(memcmp|bcmp)|\[(\])\[^\n\r]*(\n|\r\n|\r)" { target *-*-darwin* } } */
diff --git a/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c b/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c
index a9c9b18..3d43916 100644
--- a/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c
+++ b/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c
@@ -1,5 +1,6 @@
 /* { dg-do run } */
 /* { dg-options "-fno-builtin-malloc -fno-builtin-strncpy" } */
+/* { dg-additional-options "-D_FORTIFY_SOURCE=0 -gdwarf-3" { target *-*-darwin* } } */
 /* { dg-shouldfail "asan" } */
 
 #include <string.h>
@@ -14,8 +15,8 @@ int main(int argc, char **argv) {
 
 /* { dg-output "WRITE of size \[0-9\]* at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */
 /* { dg-output "    #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)strncpy|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
-/* { dg-output "    #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:11|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */
+/* { dg-output "    #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:12|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */
 /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 0 bytes to the right of 9-byte region\[^\n\r]*(\n|\r\n|\r)" } */
 /* { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */
 /* { dg-output "    #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
-/* { dg-output "    #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:10|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
+/* { dg-output "    #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:11|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
diff --git a/gcc/testsuite/g++.dg/coroutines/pr96749-1.C b/gcc/testsuite/g++.dg/coroutines/pr96749-1.C
new file mode 100644
index 0000000..941a64e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr96749-1.C
@@ -0,0 +1,42 @@
+//  { dg-additional-options "-Wall" }
+
+#include <coroutine>
+
+template <typename _Tp> struct promise;
+template <typename _Tp> struct task {
+	using promise_type = promise<_Tp>;
+	bool await_ready() noexcept { return false; }
+	void await_suspend(std::coroutine_handle<> awaiter) noexcept { m_a = awaiter; }
+	auto await_resume() { return _Tp(); }
+	std::coroutine_handle<> m_a;
+};
+
+template <typename _Tp> struct promise {
+	auto get_return_object() noexcept { return task<_Tp>(); }
+	auto initial_suspend() noexcept { return std::suspend_always(); }
+	auto final_suspend() noexcept { return std::suspend_always(); }
+	void return_value(_Tp value) noexcept { m_v = value; }
+	void unhandled_exception() noexcept {}
+	_Tp m_v;
+};
+
+task<int> test_coro(void) {
+	int r = 0;
+#if 1
+	// this code causes the unexpected warning below
+	r += co_await task<int>();
+#else
+	// this code causes no warning
+	auto b = co_await task<int>();
+	r += b;
+#endif
+	co_return r;
+	// test1.cpp: In function ‘task<int> test_coro(int)’:
+	// test1.cpp:36:1: warning: statement has no effect [-Wunused-value]
+	//   36 | }
+	//      | ^
+}
+
+int main(void) {
+	return 0;
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/pr96749-2.C b/gcc/testsuite/g++.dg/coroutines/pr96749-2.C
new file mode 100644
index 0000000..43052b5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr96749-2.C
@@ -0,0 +1,37 @@
+//  { dg-additional-options "-Wall" }
+
+#include <coroutine>
+
+#if 1
+// with a struct, GCC emits "statement has no effect"
+struct S {};
+#else
+// no warning with built-in types
+using S = int;
+#endif
+
+S Func1(int);
+
+struct C {
+	auto operator co_await() {
+		struct Awaitable final {
+			bool await_ready() const { return true; }
+			std::coroutine_handle<> await_suspend(std::coroutine_handle<>) { return {}; }
+			int await_resume() { return 42; }
+		};
+		return Awaitable{};
+	}
+};
+
+struct Task {
+	struct promise_type {
+		auto initial_suspend() { return std::suspend_always{}; }
+		auto final_suspend() noexcept { return std::suspend_always{}; }
+		void get_return_object() {}
+		void unhandled_exception() {}
+	};
+};
+
+Task Func2() {
+	Func1(co_await C());
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/pr98480.C b/gcc/testsuite/g++.dg/coroutines/pr98480.C
new file mode 100644
index 0000000..2d87261
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr98480.C
@@ -0,0 +1,20 @@
+#include <coroutine>
+
+struct future {
+  struct promise_type {
+    void return_value(int) {}
+    auto initial_suspend() { return std::suspend_never{}; }
+    auto final_suspend() noexcept { return std::suspend_never{}; }
+    void unhandled_exception() {}
+    future get_return_object() { return {}; }
+  };
+  bool await_ready() { return true; }
+  void await_suspend(std::coroutine_handle<>) {}
+  int await_resume() { return 0; }
+};
+
+future co_foo() {
+  for( int i = 0; i < co_await future{}; ++i );
+  // ICE -------------^
+  co_return 0;
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/pr99047.C b/gcc/testsuite/g++.dg/coroutines/pr99047.C
new file mode 100644
index 0000000..124633a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr99047.C
@@ -0,0 +1,83 @@
+#include <optional>
+#include <coroutine>
+
+template <typename T>
+struct [[nodiscard]] task {
+    struct promise_type  {
+        std::suspend_always initial_suspend() {
+            return {};
+        }
+        auto final_suspend() noexcept {
+            struct awaiter {
+#if 1
+                std::false_type await_ready() noexcept {
+                    return {};
+                }
+#else
+                bool await_ready() noexcept {
+                    return false;
+                }
+#endif
+                std::coroutine_handle<> await_suspend(std::coroutine_handle<>) noexcept {
+                    return next;
+                }
+                void await_resume() noexcept {
+                }
+                std::coroutine_handle<> next;
+            };
+            return awaiter{next};
+        }
+
+        void unhandled_exception() noexcept {
+            std::terminate();
+        }
+        auto get_return_object() {
+            return task(this);
+        }
+        auto coro() {
+            return std::coroutine_handle<promise_type>::from_promise(*this);
+        }
+        void return_value(T val) {
+            result.emplace(std::move(val));
+        }
+
+        std::coroutine_handle<> next;
+        std::optional<T> result;
+    };
+
+    task(task&& source) : p(std::exchange(source.p, nullptr)) {}
+    explicit task(promise_type* p) : p(p) {}
+    ~task() {
+        if (p)
+            p->coro().destroy();
+    }
+
+    bool await_ready() noexcept {
+        return p->coro().done();
+    }
+    std::coroutine_handle<> await_suspend(std::coroutine_handle<> next) noexcept {
+        p->next = next;
+        return p->coro();
+    }
+    const T& await_resume() const& noexcept {
+        return *p->result;
+    }
+
+    promise_type* p;
+};
+
+task<int> five() {
+    co_return 5;
+}
+
+task<int> six() {
+    co_return co_await five() + 1;
+}
+
+
+int main() {
+    auto task = six();
+    task.p->next = std::noop_coroutine();
+    task.p->coro().resume();
+    return *task.p->result;
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/torture/co-await-24-for-init.C b/gcc/testsuite/g++.dg/coroutines/torture/co-await-24-for-init.C
new file mode 100644
index 0000000..1bf2f6d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/torture/co-await-24-for-init.C
@@ -0,0 +1,101 @@
+// { dg-do run }
+
+// Test co-await in while condition.
+
+#include "../coro.h"
+
+// boiler-plate for tests of codegen
+#include "../coro1-ret-int-yield-int.h"
+
+/* An awaiter that suspends always and returns an int as the
+   await_resume output.  */
+struct IntAwaiter {
+  int v;
+  IntAwaiter (int _v) : v(_v) {}
+  bool await_ready () { return false; }
+  void await_suspend (coro::coroutine_handle<>) {}
+  int await_resume () { return v; }
+};
+
+struct coro1
+coro_a (bool t)
+{
+  int accum = 0;
+  for (int x = co_await IntAwaiter (3); x < 10; x++)
+    accum += x;
+
+  co_return accum;
+}
+
+struct coro1
+coro_b (bool t)
+{
+  int accum = 0;
+  int x;
+  for (x = co_await IntAwaiter (3); x < 10; x++)
+    accum += x;
+
+  co_return accum;
+}
+
+struct coro1
+coro_c (bool t)
+{
+  int accum = 0;
+  int x = 3;
+  for (co_await IntAwaiter (3); x < 10; x++)
+    accum += x;
+
+  co_return accum;
+}
+
+void
+check_a_coro (struct coro1& x)
+{
+  if (x.handle.done())
+    {
+      PRINT ("check_a_coro: apparently done when we shouldn't be...");
+      abort ();
+    }
+
+  PRINT ("check_a_coro: resume initial suspend");
+  x.handle.resume();
+
+  // will be false - so no yield expected.
+  PRINT ("check_a_coro: resume for init");
+  x.handle.resume();
+
+  int y = x.handle.promise().get_value();
+  if ( y != 42 )
+    {
+      PRINTF ("check_a_coro: apparently wrong value : %d\n", y);
+      abort ();
+    }
+
+  if (!x.handle.done())
+    {
+      PRINT ("check_a_coro: apparently not done...");
+      abort ();
+    }
+}
+
+int main ()
+{
+  {
+    struct coro1 x = coro_a (false);
+    check_a_coro (x);
+  }
+
+  {
+    struct coro1 x = coro_b (false);
+    check_a_coro (x);
+  }
+
+  {
+    struct coro1 x = coro_c (false);
+    check_a_coro (x);
+  }
+
+  PRINT ("main: done");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/torture/co-await-25-for-condition.C b/gcc/testsuite/g++.dg/coroutines/torture/co-await-25-for-condition.C
new file mode 100644
index 0000000..2208e34
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/torture/co-await-25-for-condition.C
@@ -0,0 +1,94 @@
+// { dg-do run }
+
+// Test co-await in while condition.
+
+#include "../coro.h"
+
+// boiler-plate for tests of codegen
+#include "../coro1-ret-int-yield-int.h"
+
+/* An awaiter that suspends always and returns an int as the
+   await_resume output.  */
+struct IntAwaiter {
+  int v;
+  IntAwaiter (int _v) : v(_v) {}
+  bool await_ready () { return false; }
+  void await_suspend (coro::coroutine_handle<>) {}
+  int await_resume () { return v; }
+};
+
+struct coro1
+coro_a (bool t)
+{
+  int accum = 0;
+  for (int x = 3; x < co_await IntAwaiter (10); x++)
+    accum += x;
+
+  co_return accum;
+}
+
+/* An awaiter that suspends always and returns an int as the
+   await_resume output.  */
+struct TenAwaiter {
+  int v;
+  TenAwaiter (int _v) : v(_v) {}
+  bool await_ready () { return false; }
+  void await_suspend (coro::coroutine_handle<>) {}
+  bool await_resume () { return v < 10; }
+};
+
+struct coro1
+coro_b (bool t)
+{
+  int accum = 0;
+  for (int x = 3; co_await TenAwaiter (x); x++)
+    accum += x;
+
+  co_return accum;
+}
+
+void
+check_a_coro (struct coro1& x)
+{
+  if (x.handle.done())
+    {
+      PRINT ("check_a_coro: apparently done when we shouldn't be...");
+      abort ();
+    }
+
+  PRINT ("check_a_coro: resume initial suspend");
+  x.handle.resume();
+
+  // will be false - so no yield expected.
+  PRINT ("check_a_coro: resume loops");
+  while (!x.handle.done())
+    x.handle.resume();
+
+  int y = x.handle.promise().get_value();
+  if ( y != 42 )
+    {
+      PRINTF ("check_a_coro: apparently wrong value : %d\n", y);
+      abort ();
+    }
+
+  if (!x.handle.done())
+    {
+      PRINT ("check_a_coro: apparently not done...");
+      abort ();
+    }
+}
+
+int main ()
+{
+  {
+    struct coro1 x = coro_a (false);
+    check_a_coro (x);
+  }
+  {
+    struct coro1 x = coro_b (false);
+    check_a_coro (x);
+  }
+
+  PRINT ("main: returning");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/torture/co-await-26-for-iteration-expr.C b/gcc/testsuite/g++.dg/coroutines/torture/co-await-26-for-iteration-expr.C
new file mode 100644
index 0000000..f361fb5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/torture/co-await-26-for-iteration-expr.C
@@ -0,0 +1,87 @@
+// { dg-do run }
+
+// Test co-await in while condition.
+
+#include "../coro.h"
+
+// boiler-plate for tests of codegen
+#include "../coro1-ret-int-yield-int.h"
+
+/* An awaiter that suspends always and returns an int as the
+   await_resume output.  */
+struct IntAwaiter {
+  int v;
+  IntAwaiter (int _v) : v(_v) {}
+  bool await_ready () { return false; }
+  void await_suspend (coro::coroutine_handle<>) {}
+  int await_resume () { return v; }
+};
+
+coro1
+coro_a (bool t)
+{
+  int accum = 0;
+  for (int x = 3; x < 10; x += co_await IntAwaiter (1))
+    accum += x;
+
+  co_return accum;
+}
+
+coro1
+coro_b (bool t)
+{
+  int accum = 0;
+  for (int x = 3; x < 10; x += co_await IntAwaiter (1))
+    {
+       if (x & 1)
+         continue;
+       accum += x;
+    }
+
+  co_return accum;
+}
+
+void check_a_coro (coro1& x, int expected_answer)
+{
+  if (x.handle.done())
+    {
+      PRINT ("check_a_coro: apparently done when we shouldn't be...");
+      abort ();
+    }
+
+  PRINT ("check_a_coro: resume initial suspend");
+  x.handle.resume();
+
+  // will be false - so no yield expected.
+  PRINT ("check_a_coro: resume for init");
+  while (!x.handle.done())
+    x.handle.resume();
+
+  int y = x.handle.promise().get_value();
+  if ( y != expected_answer )
+    {
+      PRINTF ("check_a_coro: apparently wrong value : %d\n", y);
+      abort ();
+    }
+
+  if (!x.handle.done())
+    {
+      PRINT ("check_a_coro: apparently not done...");
+      abort ();
+    }
+}
+
+int main ()
+{
+  {
+    coro1 x = coro_a (false);
+    check_a_coro (x, 42);
+  }
+  {
+    coro1 x = coro_b (false);
+    check_a_coro (x, 18);
+  }
+  
+  PRINT ("main: done");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/torture/pr98704.C b/gcc/testsuite/g++.dg/coroutines/torture/pr98704.C
new file mode 100644
index 0000000..15db250
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/torture/pr98704.C
@@ -0,0 +1,91 @@
+//  { dg-do run }
+#include "../coro.h"
+
+#include <stdexcept>
+
+int frame_live = 0;
+int promise_live = 0;
+int task_live = 0;
+
+struct Task
+{
+    struct promise_type;
+    using handle = std::coroutine_handle<promise_type>;
+
+    struct promise_type
+    {
+        promise_type () { promise_live++; PRINT ("promise_type ()"); }
+        ~promise_type () { promise_live--; PRINT ("~promise_type ()"); }
+        void* operator new(size_t sz) {
+            PRINT("operator new()");
+            frame_live++;
+            return ::operator new(sz);
+        }
+        void operator delete(void* p, size_t sz) {
+            PRINT("operator delete");
+            frame_live--;
+            return ::operator delete(p, sz);
+        }
+
+        Task get_return_object() { return handle::from_promise(*this); }
+        auto initial_suspend() noexcept { return std::suspend_always{}; }
+        auto final_suspend() noexcept { return std::suspend_always{}; }
+        void return_void() noexcept {}
+
+        auto yield_value(int x) noexcept
+        {
+            PRINTF ("yield_value(%d)\n", x);
+            return std::suspend_always{};
+        }
+
+        void unhandled_exception()
+        {
+            PRINT ("unhandled_exception()");
+            throw;
+        }
+    };
+
+    Task(handle h) : coro(h) { task_live++; PRINT ("Task(handle h)"); }
+    ~Task() { task_live--; PRINT ("~Task()"); if (coro) coro.destroy(); }
+
+    handle coro;
+};
+
+Task myco()
+{
+    co_yield 42;
+    throw std::out_of_range("TEST EXCEPTION");
+}
+
+int main()
+{
+  {
+    Task task = myco();
+    PRINT ("START");
+    try {
+        PRINTF ("done #0 = %d\n", task.coro.done());
+        if (task.coro.done())
+          abort();
+        task.coro.resume(); // will yield 42
+        PRINTF ("done #1 = %d\n", task.coro.done());
+        if (task.coro.done())
+          abort();        
+        task.coro.resume(); // will throw exception
+        PRINT ("should not be reached");
+        abort ();
+    }
+    catch (const std::exception&) {
+        PRINTF ("done exc = %d\n", task.coro.done());
+        if (!task.coro.done())
+          abort();        
+    }
+    if (!task.coro.done())
+      abort();        
+  } // should cause cause the destroy () to run.
+  if (task_live || promise_live || frame_live)
+    {
+      PRINTF ("task_live = %d, promise_live = %d, frame_live = %d\n",
+               task_live, promise_live, frame_live);
+      abort ();
+    }
+}
diff --git a/gcc/testsuite/g++.dg/cpp2a/consteval19.C b/gcc/testsuite/g++.dg/cpp2a/consteval19.C
new file mode 100644
index 0000000..d742f59
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/consteval19.C
@@ -0,0 +1,6 @@
+// PR c++/99507
+// { dg-do compile { target c++20 } }
+
+constexpr int i{0};
+consteval const int &iref () { return i; }
+const int *a{&iref ()};
diff --git a/gcc/testsuite/g++.dg/cpp2a/nontype-float1.C b/gcc/testsuite/g++.dg/cpp2a/nontype-float1.C
new file mode 100644
index 0000000..4fafac1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/nontype-float1.C
@@ -0,0 +1,12 @@
+// { dg-do compile { target c++20 } }
+
+#include <cmath>
+
+template<auto> class MyClass { };
+
+static_assert(__is_same(MyClass<NAN>, MyClass<NAN>));
+
+constexpr auto mynan = NAN;
+static_assert(__is_same(MyClass<mynan>, MyClass<mynan>));
+
+static_assert(__is_same(MyClass<NAN>, MyClass<mynan>));
diff --git a/gcc/testsuite/g++.dg/gomp/declare-simd-1.C b/gcc/testsuite/g++.dg/gomp/declare-simd-1.C
index dcffaec..00996b6 100644
--- a/gcc/testsuite/g++.dg/gomp/declare-simd-1.C
+++ b/gcc/testsuite/g++.dg/gomp/declare-simd-1.C
@@ -287,7 +287,7 @@ struct D
   int f37 (int a);
   int e;
 };
-// { dg-warning "GCC does not currently support simdlen 16 for type 'int'" "" { target aarch64*-*-* } .-3 }
+// { dg-warning "GCC does not currently support mixed size types for 'simd' functions" "" { target aarch64*-*-* } .-3 }
 
 void
 f38 (D &d)
diff --git a/gcc/testsuite/g++.dg/modules/builtin-3_a.C b/gcc/testsuite/g++.dg/modules/builtin-3_a.C
index ad30ccf..fb7da61 100644
--- a/gcc/testsuite/g++.dg/modules/builtin-3_a.C
+++ b/gcc/testsuite/g++.dg/modules/builtin-3_a.C
@@ -30,8 +30,8 @@ export inline int count (int a, ...)
 // The implementation details of va_list's are target-specific.
 // Usually one of two patterns though
 // { dg-final { scan-lang-dump-not { Cluster members:\n  \[0\]=decl declaration '::__builtin_va_list'\n  \[1\]=binding '::__builtin_va_list'\n} module { target i?86-*-linux* x86_64-*-linux* } } }
-// { dg-final { scan-lang-dump {Wrote GMF:-[0-9]* type_decl:'::__builtin_va_list'@builtins} module { target x86_64-*-linux* } } }
-// { dg-final { scan-lang-dump {Writing:-[0-9]*'s named merge key \(decl\) type_decl:'::__builtin_va_list'} module { target x86_64-*-linux* } } }
+// { dg-final { scan-lang-dump {Wrote GMF:-[0-9]* type_decl:'::__builtin_va_list'@builtins} module { target { { x86_64-*-linux* i?86-*-linux* } && lp64 } } } }
+// { dg-final { scan-lang-dump {Writing:-[0-9]*'s named merge key \(decl\) type_decl:'::__builtin_va_list'} module { target { { x86_64-*-linux* i?86-*-linux* } && lp64 } } } }
 
 // { dg-final { scan-lang-dump {Writing:-1's named merge key \(decl\) type_decl:'::__gnuc_va_list'} module { target i?86-*-linux* *-*-darwin* } } }
 // { dg-final { scan-lang-dump {Wrote GMF:-3 type_decl:'::__gnuc_va_list'@builtins} module { target i?86-*-linux* *-*-darwin* } } }
diff --git a/gcc/testsuite/g++.dg/modules/builtin-3_b.C b/gcc/testsuite/g++.dg/modules/builtin-3_b.C
index 93489bd..e0e6306 100644
--- a/gcc/testsuite/g++.dg/modules/builtin-3_b.C
+++ b/gcc/testsuite/g++.dg/modules/builtin-3_b.C
@@ -8,6 +8,6 @@ int main ()
 }
 
 // { dg-final { scan-lang-dump {Read:-[0-9]*'s named merge key \(matched\) function_decl:'::__builtin_strlen'} module } }
-// { dg-final { scan-lang-dump {Read:-[0-9]*'s named merge key \(matched\) type_decl:'::__builtin_va_list'} module { target { x86_64-*-linux* } } } }
+// { dg-final { scan-lang-dump {Read:-[0-9]*'s named merge key \(matched\) type_decl:'::__builtin_va_list'} module { target { { x86_64-*-linux* i?86-*-linux* } && lp64 } } } }
 // { dg-final { scan-lang-dump {Read:-[0-9]*'s named merge key \(new\) type_decl:'::va_list'} module } }
 // { dg-final { scan-lang-dump {Read:-[0-9]*'s named merge key \(new\) type_decl:'::__gnuc_va_list'} module } }
diff --git a/gcc/testsuite/g++.dg/modules/pr99238.h b/gcc/testsuite/g++.dg/modules/pr99238.h
new file mode 100644
index 0000000..312641f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr99238.h
@@ -0,0 +1 @@
+struct tm;
diff --git a/gcc/testsuite/g++.dg/modules/pr99238_a.H b/gcc/testsuite/g++.dg/modules/pr99238_a.H
new file mode 100644
index 0000000..b594c09
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr99238_a.H
@@ -0,0 +1,4 @@
+// PR 99238 ICE with using decl
+// { dg-additional-options -fmodule-header }
+// { dg-module-cmi {} }
+#include "pr99238.h"
diff --git a/gcc/testsuite/g++.dg/modules/pr99238_b.H b/gcc/testsuite/g++.dg/modules/pr99238_b.H
new file mode 100644
index 0000000..070ee36
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr99238_b.H
@@ -0,0 +1,8 @@
+// { dg-additional-options -fmodule-header }
+// { dg-module-cmi {} }
+#include "pr99238.h"
+import "pr99238_a.H";
+namespace std
+{
+  using ::tm;
+}
diff --git a/gcc/testsuite/g++.dg/modules/pr99496_a.H b/gcc/testsuite/g++.dg/modules/pr99496_a.H
new file mode 100644
index 0000000..71b77fb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr99496_a.H
@@ -0,0 +1,17 @@
+// PR 99496 different types with same canonical
+// (requires spec hasher to be a constant, so we get collisions)
+// { dg-additional-options -fmodule-header }
+// { dg-module-cmi {} }
+
+template<typename...> using __void_t = void;
+
+template<typename _Tp, typename = void>
+struct __is_referenceable
+{ };
+
+template<typename _Tp>
+struct __is_referenceable<_Tp, __void_t<_Tp&>>
+{ };
+
+template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+struct __is_copy_constructible_impl;
diff --git a/gcc/testsuite/g++.dg/modules/pr99496_b.C b/gcc/testsuite/g++.dg/modules/pr99496_b.C
new file mode 100644
index 0000000..57b71d1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr99496_b.C
@@ -0,0 +1,3 @@
+// { dg-additional-options {-fmodules-ts -fno-module-lazy} }
+
+import "pr99496_a.H";
diff --git a/gcc/testsuite/g++.dg/opt/pr98834.C b/gcc/testsuite/g++.dg/opt/pr98834.C
new file mode 100644
index 0000000..fafd322
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr98834.C
@@ -0,0 +1,71 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target c++17 } */
+/* { dg-options "-O2 -fdump-tree-fre3" } */
+
+struct _Base
+{ 
+  int _M_data = 0;
+};
+
+struct _Wrapper : _Base
+{ 
+  _Wrapper(int) {}
+
+  bool _M_is_constprop() { return __builtin_constant_p(_M_data); }
+};
+
+struct _Impl
+{ 
+  _Wrapper _S_multiplies(_Wrapper __x, _Wrapper __y)
+  { 
+    if (__x._M_is_constprop() || __y._M_is_constprop())
+      return __y;
+    return 0;
+  }
+};
+
+struct _TupleData
+{ 
+  _Wrapper first;
+  int second;
+};
+
+struct _Tuple : _TupleData
+{ 
+  template <typename _Fp>
+    _Tuple _M_apply_per_chunk(_Fp __fun, _Tuple __y)
+    { 
+      return {__fun(first, __y.first), second};
+    }
+};
+
+struct _ImplFixed
+{ 
+  static _Tuple _S_multiplies(_Tuple __x, _Tuple __y)
+  { 
+    return __x._M_apply_per_chunk(
+             []( auto __xx, auto __yy) {
+               return _Impl()._S_multiplies(__xx, __yy);
+             },
+             __y);
+  }
+};
+
+class simd
+{
+public:
+  [[__gnu__::__always_inline__]] friend simd operator*(simd __x, simd __y)
+  { return _ImplFixed::_S_multiplies(__x._M_data, __y._M_data); }
+
+  simd(_Tuple __init) : _M_data(__init) {}
+
+  _Tuple _M_data;
+};
+
+int main()
+{ 
+  simd({0, 0}) * simd({0, 0});
+}
+
+/* FRE3 should elide all conditionals in the remaining main.  */
+/* { dg-final { scan-tree-dump-times "<bb" 1 "fre3" } } */
diff --git a/gcc/testsuite/g++.dg/vect/simd-clone-7.cc b/gcc/testsuite/g++.dg/vect/simd-clone-7.cc
index 527bbd9..fd5751b 100644
--- a/gcc/testsuite/g++.dg/vect/simd-clone-7.cc
+++ b/gcc/testsuite/g++.dg/vect/simd-clone-7.cc
@@ -8,5 +8,3 @@ bar (float x, float *y, int)
 {
   return y[0] + y[1] * x;
 }
-// { dg-warning "GCC does not currently support mixed size types for 'simd' functions" "" { target { { aarch64*-*-* } && lp64 } } .-4 }
-
diff --git a/gcc/testsuite/g++.target/i386/pr99108.C b/gcc/testsuite/g++.target/i386/pr99108.C
new file mode 100644
index 0000000..b1f0a71
--- /dev/null
+++ b/gcc/testsuite/g++.target/i386/pr99108.C
@@ -0,0 +1,19 @@
+/* PR c++/99108 */
+/* { dg-require-ifunc "" }  */
+
+struct A {
+  template <class T>
+  void foo(T);
+};
+template <class T>
+void A::foo(T)
+{
+  int f(void) __attribute__((target("default")));
+  int f(void) __attribute__((target("arch=atom")));
+  int b = f();
+}
+void bar(void)
+{
+  A c;
+  c.foo(7);
+}
diff --git a/gcc/testsuite/gcc.dg/Wstringop-truncation-9.c b/gcc/testsuite/gcc.dg/Wstringop-truncation-9.c
new file mode 100644
index 0000000..6361480
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/Wstringop-truncation-9.c
@@ -0,0 +1,41 @@
+/* PR tree-optimization/99489 - ICE calling strncat after strncat
+   { dg-do compile }
+   { dg-options "-O2 -Wall" } */
+
+// Important -- see pr82429.
+char *stpcpy (char *, const char *);
+
+void fchar (char *d, char c, char *s)
+{
+  __builtin_strcat (d, s);
+  __builtin_strncat (d, &c, 1);
+}
+
+void fcstchar (char *d, char *s)
+{
+  __builtin_strcat (d, s);
+
+  const char c = 'x';
+  __builtin_strncat (d, &c, 1);     // { dg-warning "-Wstringop-truncation" }
+}
+
+void fstr (char *d, char *s)
+{
+  __builtin_strcat (d, s);
+  __builtin_strncat (d, s, 1);
+}
+
+void farr (char *d, char *s)
+{
+  __builtin_strcat (d, s);
+
+  char a[] = "x";
+  __builtin_strncat (d, a, 1);      // { dg-warning "-Wstringop-truncation" }
+}
+
+void flit (char *d, char *s)
+{
+  __builtin_strcat (d, s);
+  __builtin_strncat (d, "x", 1);    // { dg-warning "-Wstringop-truncation" "pr?????" { xfail *-*-*} }
+                                    // { dg-warning "-Wstringop-overflow" "actual" { target *-*-*} .-1 }
+}
diff --git a/gcc/testsuite/gcc.dg/declare-simd.c b/gcc/testsuite/gcc.dg/declare-simd.c
index 1c71b60..2c8c1b7 100644
--- a/gcc/testsuite/gcc.dg/declare-simd.c
+++ b/gcc/testsuite/gcc.dg/declare-simd.c
@@ -3,6 +3,7 @@
 
 #pragma omp declare simd linear (p2, p3)
 extern void fn2 (float p1, float *p2, float *p3);
+/* { dg-warning "GCC does not currently support mixed size types for 'simd' functions" "" { target { { aarch64*-*-* } && lp64 } } .-1 } */
 
 float *a, *b;
 void fn1 (float *p1)
diff --git a/gcc/testsuite/gcc.dg/gomp/pr59669-2.c b/gcc/testsuite/gcc.dg/gomp/pr59669-2.c
index 26a30f4..f6aad89 100644
--- a/gcc/testsuite/gcc.dg/gomp/pr59669-2.c
+++ b/gcc/testsuite/gcc.dg/gomp/pr59669-2.c
@@ -7,4 +7,3 @@ void
 bar (int *a)
 {
 }
-/* { dg-warning "GCC does not currently support mixed size types for 'simd' functions" "" { target aarch64*-*-* } .-3 } */
diff --git a/gcc/testsuite/gcc.dg/gomp/pr99542.c b/gcc/testsuite/gcc.dg/gomp/pr99542.c
new file mode 100644
index 0000000..b67ff5a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gomp/pr99542.c
@@ -0,0 +1,17 @@
+/* PR middle-end/89246 */
+/* { dg-do compile { target int128 } } */
+/* { dg-options "-O0 -fopenmp-simd" } */
+
+#pragma omp declare simd
+extern int foo (__int128 x);	/* { dg-warning "GCC does not currently support mixed size types for 'simd' function" "" { target aarch64*-*-* } } */
+/* { dg-warning "unsupported argument type '__int128' for simd" "" { target i?86-*-* x86_64-*-* } .-1 } */
+
+#pragma omp declare simd uniform (x)
+extern int baz (__int128 x);
+
+#pragma omp declare simd
+int
+bar (int x)
+{
+  return x + foo (0) + baz (0);
+}
diff --git a/gcc/testsuite/gcc.dg/gomp/pr99544.c b/gcc/testsuite/gcc.dg/gomp/pr99544.c
new file mode 100644
index 0000000..4ea07cf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gomp/pr99544.c
@@ -0,0 +1,13 @@
+/* PR tree-optimization/99544 */
+/* { dg-do compile } */
+/* { dg-options "-Os -fopenmp" } */
+
+long
+foo (long a, long b, long c)
+{
+  long d, e;
+  #pragma omp teams distribute parallel for simd firstprivate (a, b, c) lastprivate(e)
+  for (d = a; d < b; d++)
+    e = c + d * 5;
+  return e;
+}
diff --git a/gcc/testsuite/gcc.dg/gomp/simd-clones-2.c b/gcc/testsuite/gcc.dg/gomp/simd-clones-2.c
index 844b80b..75554de 100644
--- a/gcc/testsuite/gcc.dg/gomp/simd-clones-2.c
+++ b/gcc/testsuite/gcc.dg/gomp/simd-clones-2.c
@@ -15,7 +15,6 @@ float setArray(float *a, float x, int k)
   return a[k];
 }
 
-/* { dg-warning "GCC does not currently support mixed size types for 'simd' functions" "" { target aarch64*-*-* } .-6 } */
 /* { dg-final { scan-tree-dump "_ZGVbN4ua32vl_setArray" "optimized" { target i?86-*-* x86_64-*-* } } } */
 /* { dg-final { scan-tree-dump "_ZGVbN4vvva32_addit" "optimized" { target i?86-*-* x86_64-*-* } } } */
 /* { dg-final { scan-tree-dump "_ZGVbM4vl66u_addit" "optimized" { target i?86-*-* x86_64-*-* } } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/acle/rng_2.c b/gcc/testsuite/gcc.target/aarch64/acle/rng_2.c
new file mode 100644
index 0000000..206136c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/acle/rng_2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=armv8.5-a+rng" } */
+
+#include <arm_acle.h>
+
+int test_rndr (uint64_t *addr)
+{
+  return  __rndr (addr);
+}
+
+/* { dg-final { scan-assembler-times {cset\t...?, eq} 1 } } */
+
diff --git a/gcc/testsuite/gcc.target/arm/pr99592.c b/gcc/testsuite/gcc.target/arm/pr99592.c
new file mode 100644
index 0000000..23d6591
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pr99592.c
@@ -0,0 +1,7 @@
+/* PR target/99592 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -pg" } */
+
+#pragma GCC push_options
+#pragma GCC target ""
+#pragma GCC pop_options
diff --git a/gcc/testsuite/gcc.target/i386/avx-pr99563.c b/gcc/testsuite/gcc.target/i386/avx-pr99563.c
new file mode 100644
index 0000000..e2e863b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx-pr99563.c
@@ -0,0 +1,38 @@
+/* PR target/99563 */
+/* { dg-do run { target avx } } */
+/* { dg-options "-O2 -mavx -mno-vzeroupper" } */
+
+#include "avx-check.h"
+#include <immintrin.h>
+
+
+__attribute__((noipa)) float
+compute_generic (void)
+{
+  return 0.0f;
+}
+
+static inline __attribute__((always_inline))
+float compute_avx (unsigned long block_count)
+{
+  __m128d mm_res = _mm_set1_pd (256.0);
+  float res = (float) (_mm_cvtsd_f64 (mm_res) / (double) block_count);
+  _mm256_zeroupper ();
+  return res;
+}
+
+__attribute__((noipa)) float
+compute (unsigned long block_count)
+{
+  if (block_count >= 64)
+    return compute_avx (block_count);
+  else
+    return compute_generic ();
+}
+
+static void
+avx_test (void)
+{
+  if (compute (128) != 2.0f || compute (32) != 0.0f)
+    abort ();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512vl-pr99321-2.c b/gcc/testsuite/gcc.target/i386/avx512vl-pr99321-2.c
new file mode 100644
index 0000000..8bb3a03
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512vl-pr99321-2.c
@@ -0,0 +1,94 @@
+/* PR target/99321 */
+/* { dg-do assemble { target lp64 } } */
+/* { dg-require-effective-target avx512vl } */
+/* { dg-require-effective-target assembler_march_noavx512bw } */
+/* { dg-options "-O2 -mavx512vl -mno-avx512bw -Wa,-march=+noavx512bw" } */
+
+#include <x86intrin.h>
+
+typedef unsigned char V1 __attribute__((vector_size (16)));
+typedef unsigned char V2 __attribute__((vector_size (32)));
+typedef unsigned short V3 __attribute__((vector_size (16)));
+typedef unsigned short V4 __attribute__((vector_size (32)));
+
+void f1 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_abs_epi8 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f2 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_abs_epi8 ((__m256i) b); __asm ("" : : "v" (a)); }
+void f3 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_abs_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f4 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_abs_epi16 ((__m256i) b); __asm ("" : : "v" (a)); }
+void f5 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_adds_epi8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f6 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_adds_epi8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f7 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_adds_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f8 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_adds_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f9 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_subs_epi8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f10 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_subs_epi8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f11 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_subs_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f12 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_subs_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f13 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_adds_epu8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f14 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_adds_epu8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f15 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_adds_epu16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f16 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_adds_epu16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f17 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_subs_epu8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f18 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_subs_epu8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f19 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_subs_epu16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f20 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_subs_epu16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f21 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_alignr_epi8 ((__m128i) a, (__m128i) b, 5); __asm ("" : : "v" (a)); }
+void f22 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_alignr_epi8 ((__m256i) a, (__m256i) b, 5); __asm ("" : : "v" (a)); }
+void f23 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_adds_epu16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f24 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_avg_epu8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f25 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_avg_epu8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f26 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_avg_epu16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f27 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_avg_epu16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f28 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_broadcastb_epi8 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f29 (void) { register V2 a __asm ("%xmm16"); register V1 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_broadcastb_epi8 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f30 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_broadcastw_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f31 (void) { register V4 a __asm ("%xmm16"); register V3 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_broadcastw_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+int f32 (void) { register V1 a __asm ("%xmm16"); __asm ("" : "=v" (a)); return _mm_extract_epi8 ((__m128i) a, 3); }
+int f33 (void) { register V3 a __asm ("%xmm16"); __asm ("" : "=v" (a)); return _mm_extract_epi16 ((__m128i) a, 3); }
+void f34 (int c) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_insert_epi8 ((__m128i) b, c, 5); __asm ("" : : "v" (a)); }
+void f35 (int c) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_insert_epi16 ((__m128i) b, c, 5); __asm ("" : : "v" (a)); }
+void f36 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_maddubs_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f37 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_maddubs_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f38 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_madd_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f39 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_madd_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f40 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_cvtepi8_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f41 (void) { register V4 a __asm ("%xmm16"); register V3 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_cvtepi8_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f42 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_cvtepu8_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f43 (void) { register V4 a __asm ("%xmm16"); register V3 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_cvtepu8_epi16 ((__m128i) b); __asm ("" : : "v" (a)); }
+void f44 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_mulhrs_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f45 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_mulhrs_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f46 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_mulhi_epu16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f47 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_mulhi_epu16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f48 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_mulhi_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f49 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_mulhi_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f50 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_sad_epu8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f51 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_sad_epu8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f52 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_shuffle_epi8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f53 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_shuffle_epi8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f54 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_shufflehi_epi16 ((__m128i) b, 0x5b); __asm ("" : : "v" (a)); }
+void f55 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_shufflehi_epi16 ((__m256i) b, 0x5b); __asm ("" : : "v" (a)); }
+void f56 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_shufflelo_epi16 ((__m128i) b, 0x5b); __asm ("" : : "v" (a)); }
+void f57 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_shufflelo_epi16 ((__m256i) b, 0x5b); __asm ("" : : "v" (a)); }
+void f58 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_slli_si128 ((__m128i) b, 3); __asm ("" : : "v" (a)); }
+void f59 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_slli_si256 ((__m256i) b, 3); __asm ("" : : "v" (a)); }
+void f60 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_srli_si128 ((__m128i) b, 3); __asm ("" : : "v" (a)); }
+void f61 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_srli_si256 ((__m256i) b, 3); __asm ("" : : "v" (a)); }
+void f62 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_sll_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f63 (void) { register V4 a __asm ("%xmm16"); register V3 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_sll_epi16 ((__m256i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f64 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_slli_epi16 ((__m128i) b, 7); __asm ("" : : "v" (a)); }
+void f65 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_slli_epi16 ((__m256i) b, 7); __asm ("" : : "v" (a)); }
+void f66 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_srl_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f67 (void) { register V4 a __asm ("%xmm16"); register V3 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_srl_epi16 ((__m256i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f68 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_srli_epi16 ((__m128i) b, 7); __asm ("" : : "v" (a)); }
+void f69 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_srli_epi16 ((__m256i) b, 7); __asm ("" : : "v" (a)); }
+void f70 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_sra_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f71 (void) { register V4 a __asm ("%xmm16"); register V3 b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_sra_epi16 ((__m256i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f72 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_srai_epi16 ((__m128i) b, 7); __asm ("" : : "v" (a)); }
+void f73 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_srai_epi16 ((__m256i) b, 7); __asm ("" : : "v" (a)); }
+void f74 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_unpackhi_epi8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f75 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_unpackhi_epi8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f76 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_unpackhi_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f77 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_unpackhi_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f78 (void) { register V1 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V1) _mm_unpacklo_epi8 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f79 (void) { register V2 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V2) _mm256_unpacklo_epi8 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
+void f80 (void) { register V3 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V3) _mm_unpacklo_epi16 ((__m128i) a, (__m128i) b); __asm ("" : : "v" (a)); }
+void f81 (void) { register V4 a __asm ("%xmm16"), b __asm ("%xmm17"); __asm ("" : "=v" (a), "=v" (b)); a = (V4) _mm256_unpacklo_epi16 ((__m256i) a, (__m256i) b); __asm ("" : : "v" (a)); }
diff --git a/gcc/testsuite/gcc.target/i386/pr99530-1.c b/gcc/testsuite/gcc.target/i386/pr99530-1.c
new file mode 100644
index 0000000..080d7cc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99530-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target { i?86-*-linux* x86_64-*-linux* } } } */
+/* { dg-require-effective-target lp64 } */
+/* { dg-options "-O2 -fpic -mcmodel=large -fno-plt" } */
+/* { dg-final { scan-assembler-not "foo@GOTPCREL" } } */
+
+extern void foo (void); 
+void
+bar (void)
+{
+  asm ("call %P0" : : "X" (foo));
+} 
diff --git a/gcc/testsuite/gcc.target/i386/pr99530-2.c b/gcc/testsuite/gcc.target/i386/pr99530-2.c
new file mode 100644
index 0000000..9808957
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99530-2.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target { i?86-*-linux* x86_64-*-linux* } } } */
+/* { dg-require-effective-target lp64 } */
+/* { dg-options "-O2 -fno-pic -mcmodel=large -fno-plt" } */
+/* { dg-final { scan-assembler-not "foo@GOTPCREL" } } */
+
+extern void foo (void); 
+void
+bar (void)
+{
+  asm ("call %P0" : : "X" (foo));
+} 
diff --git a/gcc/testsuite/gcc.target/i386/pr99530-3.c b/gcc/testsuite/gcc.target/i386/pr99530-3.c
new file mode 100644
index 0000000..22fe81b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99530-3.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target { i?86-*-linux* x86_64-*-linux* } } } */
+/* { dg-options "-O2 -fno-pic -fno-plt" } */
+/* { dg-final { scan-assembler "call\[ \t\]+\[*\]foo@GOTPCREL" { target { ! ia32 } } } } */
+/* { dg-final { scan-assembler "call\[ \t\]+\[*\]foo@GOT" { target { ia32 && got32x_reloc } } } } */
+
+extern void foo (void); 
+void
+bar (void)
+{
+  asm ("call %P0" : : "X" (foo));
+} 
diff --git a/gcc/testsuite/gcc.target/i386/pr99530-4.c b/gcc/testsuite/gcc.target/i386/pr99530-4.c
new file mode 100644
index 0000000..aba0b5d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99530-4.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target { i?86-*-linux* x86_64-*-linux* } } } */
+/* { dg-options "-O2 -fpic -fno-plt" } */
+/* { dg-final { scan-assembler "call\[ \t\]+\[*\]foo@GOTPCREL" { target { ! ia32 } } } } */
+/* { dg-final { scan-assembler-not "foo@GOT" { target { ia32 } } } } */
+
+extern void foo (void);
+void
+bar (void)
+{
+  asm ("call %P0" : : "X" (foo));
+} 
diff --git a/gcc/testsuite/gcc.target/i386/pr99530-5.c b/gcc/testsuite/gcc.target/i386/pr99530-5.c
new file mode 100644
index 0000000..02c5799
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99530-5.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target { i?86-*-linux* x86_64-*-linux* } } } */
+/* { dg-options "-O2 -fno-pic" } */
+/* { dg-final { scan-assembler "call\[ \t\]+\[*\]foo@GOTPCREL" { target { ! ia32 } } } } */
+/* { dg-final { scan-assembler "call\[ \t\]+\[*\]foo@GOT" { target { ia32 && got32x_reloc } } } } */
+
+extern void foo (void) __attribute__ ((noplt)); 
+void
+bar (void)
+{
+  asm ("call %P0" : : "X" (foo));
+} 
diff --git a/gcc/testsuite/gcc.target/i386/pr99530-6.c b/gcc/testsuite/gcc.target/i386/pr99530-6.c
new file mode 100644
index 0000000..0dfdd37
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99530-6.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target { i?86-*-linux* x86_64-*-linux* } } } */
+/* { dg-options "-O2 -fpic" } */
+/* { dg-final { scan-assembler "call\[ \t\]+\[*\]foo@GOTPCREL" { target { ! ia32 } } } } */
+/* { dg-final { scan-assembler-not "foo@GOT" { target { ia32 } } } } */
+
+extern void foo (void) __attribute__ ((noplt)); 
+void
+bar (void)
+{
+  asm ("call %P0" : : "X" (foo));
+} 
diff --git a/gcc/testsuite/gcc.target/i386/pr99600.c b/gcc/testsuite/gcc.target/i386/pr99600.c
new file mode 100644
index 0000000..c2f2b22
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr99600.c
@@ -0,0 +1,16 @@
+/* PR target/99600 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=atom" } */
+
+char a, b;
+long c;
+
+long
+foo (void)
+{
+  if (a)
+    c = b == 1 ? 1 << 3 : 1 << 2;
+  else
+    c = 0;
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/pr98092.c b/gcc/testsuite/gcc.target/powerpc/pr98092.c
new file mode 100644
index 0000000..03eab5a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr98092.c
@@ -0,0 +1,7 @@
+/* { dg-options "-mdejagnu-cpu=power9 -ffinite-math-only" } */
+
+int
+h9 (__attribute__ ((altivec (vector__))) char un)
+{
+  return (__builtin_vec_bcdinvalid (un));
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/pr99492.c b/gcc/testsuite/gcc.target/powerpc/pr99492.c
index ae36cb3..37a1d07 100644
--- a/gcc/testsuite/gcc.target/powerpc/pr99492.c
+++ b/gcc/testsuite/gcc.target/powerpc/pr99492.c
@@ -1,7 +1,7 @@
 /* { dg-do run { target { powerpc*-ibm-aix* } } } */
 /* { dg-options "" } */
 
-void abort (void);
+extern void abort (void);
 
 struct A {
     double _Complex a[64];
@@ -26,10 +26,10 @@ int main() {
     abort();
 
   if (__alignof(struct A) != 8)
-    abort;
+    abort();
 
   if (__alignof(struct C) != 4)
-    abort;
+    abort();
 
   if (__builtin_offsetof(struct C, c2) != 4)
     abort();
diff --git a/gcc/testsuite/gcc.target/s390/vector/long-double-asm-fprvrmem.c b/gcc/testsuite/gcc.target/s390/vector/long-double-asm-fprvrmem.c
new file mode 100644
index 0000000..f95656c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/s390/vector/long-double-asm-fprvrmem.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -march=z14 -mzarch" } */
+
+long double
+foo (long double x)
+{
+  x = x * x;
+  asm("# %0" : "+fvm"(x));
+  x = x + x;
+  return x;
+}
diff --git a/gcc/testsuite/gfortran.dg/alloc_deferred_comp_1.f90 b/gcc/testsuite/gfortran.dg/alloc_deferred_comp_1.f90
new file mode 100644
index 0000000..0fc54d5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/alloc_deferred_comp_1.f90
@@ -0,0 +1,18 @@
+! { dg-do run }
+!
+! Test the fix for PR99125, where the array reference in the print
+! statement caused an ICE because the gimplifier complained about '0'
+! being used as an lvalue.
+!
+! Contributed by Gerhard Steinmetz  <gscfq@t-online.de>
+!
+program p
+   type t
+      character(:), allocatable :: a(:)
+   end type
+   type(t) :: x
+   character(8) :: c(3) = ['12 45 78','23 56 89','34 67 90']
+   x%a = c
+   if (any (x%a(2:3) .ne. ['23 56 89','34 67 90'])) stop 1
+   if (any (x%a(2:3)(4:5) .ne. ['56','67'])) stop 2 ! Bizarrely this worked.
+end
diff --git a/gcc/testsuite/gfortran.dg/do_check_16.f90 b/gcc/testsuite/gfortran.dg/do_check_16.f90
new file mode 100644
index 0000000..db0d45c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/do_check_16.f90
@@ -0,0 +1,13 @@
+! { dg-do compile }
+program main
+  implicit none
+  integer :: iq,nq,recl
+  DO iq = 1, nq
+     call foobar  ! { dg-error "redefined" }     
+  ENDDO  
+CONTAINS
+
+  subroutine foobar
+    inquire (iolength=nq) iq ! { dg-error "redefined" }
+  end subroutine foobar
+END program main
diff --git a/gcc/testsuite/gfortran.dg/do_check_17.f90 b/gcc/testsuite/gfortran.dg/do_check_17.f90
new file mode 100644
index 0000000..02b8993
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/do_check_17.f90
@@ -0,0 +1,16 @@
+! { dg-do compile }
+! PR 99345 - this used to cause an ICE.
+! Original test case by Matthias Klose
+program main
+  implicit none
+  integer :: iq,nq,recl
+  DO iq = 1, nq
+     CALL calc_upper_fan (iq)
+  ENDDO  
+CONTAINS
+  SUBROUTINE calc_upper_fan (iq)
+    INTEGER :: iq
+    INTEGER :: recl
+    INQUIRE(IOLENGTH=recl) iq
+  END SUBROUTINE calc_upper_fan
+END
diff --git a/gcc/testsuite/gfortran.dg/gomp/threadprivate-1.f90 b/gcc/testsuite/gfortran.dg/gomp/threadprivate-1.f90
new file mode 100644
index 0000000..59656c2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gomp/threadprivate-1.f90
@@ -0,0 +1,11 @@
+! PR fortran/99514
+!
+! NTest in DATA is implicitly SAVE, unless in COMMON
+! Was failing before as the implicit SAVE was not
+! honoured by the threadprivate check.
+!
+
+program main
+  DATA NTest /1/
+  !$omp threadprivate(Ntest)
+end program main
diff --git a/gcc/testsuite/gfortran.dg/pr99112.f90 b/gcc/testsuite/gfortran.dg/pr99112.f90
new file mode 100644
index 0000000..9401061
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr99112.f90
@@ -0,0 +1,27 @@
+! { dg-do compile }
+! { dg-options "-fcheck=pointer -fdump-tree-original" }
+! PR99112 - ICE with runtime diagnostics for SIZE intrinsic function
+ 
+module m
+  type t
+  end type
+contains
+  function f (x, y) result(z)
+    class(t) :: x(:)
+    class(t) :: y(size(x))
+    type(t)  :: z(size(x))
+  end
+  function g (x) result(z)
+    class(*) :: x(:)
+    type(t)  :: z(size(x))
+  end
+  subroutine s ()
+    class(t), allocatable :: a(:), b(:), c(:), d(:)
+    class(t), pointer     :: p(:)
+    c = f (a, b)
+    d = g (p)
+  end
+end
+! { dg-final { scan-tree-dump-times "_gfortran_runtime_error_at" 3 "original" } }
+! { dg-final { scan-tree-dump-times "Allocatable actual argument" 2 "original" } }
+! { dg-final { scan-tree-dump-times "Pointer actual argument" 1 "original" } }
diff --git a/gcc/testsuite/gfortran.dg/pr99545.f90 b/gcc/testsuite/gfortran.dg/pr99545.f90
new file mode 100644
index 0000000..1b5ed5d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr99545.f90
@@ -0,0 +1,40 @@
+! { dg-do compile }
+! { dg-options "-fcheck=mem" }
+!
+! Test the fix for PR99545, in which the allocate statements caused an ICE.
+!
+! Contributed by Juergen Reuter  <juergen.reuter@desy.de>
+!
+module commands
+  implicit none
+  private
+
+  type, abstract :: range_t
+     integer :: step_mode = 0
+     integer :: n_step = 0
+  end type range_t
+
+  type, extends (range_t) :: range_int_t
+     integer :: i_step = 0
+  end type range_int_t
+
+  type, extends (range_t) :: range_real_t
+     real :: lr_step = 0
+end type range_real_t
+
+  type :: cmd_scan_t
+     private
+     class(range_t), dimension(:), allocatable :: range
+   contains
+     procedure :: compile => cmd_scan_compile
+  end type cmd_scan_t
+
+contains
+
+  subroutine cmd_scan_compile (cmd)
+    class(cmd_scan_t), intent(inout) :: cmd
+    allocate (range_int_t :: cmd%range (3))
+    allocate (range_real_t :: cmd%range (3))
+  end subroutine cmd_scan_compile
+
+end module commands