Index: gcc/testsuite/ChangeLog.pph

2011-07-12  Lawrence Crowl  <crowl@google.com>

	* lib/dg-pph.exp (dg-pph-pos): Add support for link tests.
	(dg-pph-neg): Remove incorrect -fpph-gen option.
	Delete unneeded assembly files.
	(dg-pph-hdr): Delete unneeded assembly files.
	* g++.dg/pph/pph.exp: Autogenerate pph.map instead of manual tracking.
	Recognise headers with any prefix in [cdpxy].
	* g++.dg/pph/pph.map: Remove.
	* g++.dg/pph/c1pr36533.h: Rename to p1pr36533.h; edit deps.
	* g++.dg/pph/c1pr36533.cc: Rename to p1pr36533.cc.
	* g++.dg/pph/c4eabi1.h: Rename to p4eabi1.h; edit deps.
	* g++.dg/pph/c4eabi1.cc: Rename to p4eabi1.cc.
	* g++.dg/pph/c4meteor-contest.h: Rename to p4meteor-contest.h;
	edit deps.
	* g++.dg/pph/c4meteor-contest.cc: Rename to p4meteor-contest.cc.
	* g++.dg/pph/c4pr36533.h: Rename to p4pr36533.h; edit deps.
	* g++.dg/pph/c4pr36533.cc: Rename to p4pr36533.cc.
	* g++.dg/pph/c1eabi1.cc: Correct test expectation.
	* g++.dg/pph/x1dynarray1.cc: Make link test; correct test expectation.
	* g++.dg/pph/x1dynarray2a.cc: Make link test; correct test expectation.
	* g++.dg/pph/x1dynarray2b.cc: Make link test; correct test expectation.
	* g++.dg/pph/x6dynarray3.cc: Correct test expectation.
	* g++.dg/pph/x6dynarray4.cc: Correct test expectation.
	* g++.dg/pph/x6dynarray5.cc: Correct test expectation.


Index: gcc/testsuite/lib/dg-pph.exp
===================================================================
--- gcc/testsuite/lib/dg-pph.exp	(revision 176223)
+++ gcc/testsuite/lib/dg-pph.exp	(working copy)
@@ -35,6 +35,9 @@ proc dg-pph-hdr { subdir test options ma
     set dg-do-what-default preparse
     dg-test -keep-output $test "-fpph-gen $options $mapflag -I." ""
 
+    if { [file_on_host exists "$bname.s"] } {
+	file_on_host delete "$bname.s"
+    }
 }
 
 proc dg-pph-neg { subdir test options mapflag suffix } {
@@ -51,8 +54,9 @@ proc dg-pph-neg { subdir test options ma
     verbose -log "\nTesting $nshort, $options"
 
     set dg-do-what-default compile
-    dg-test -keep-output $test "-fpph-gen $options $mapflag -I." ""
-    if { ![file_on_host exists "$bname.s"] } {
+    dg-test -keep-output $test "$options $mapflag -I." ""
+
+    if { [file_on_host exists "$bname.s"] } {
 	file_on_host delete "$bname.s"
     }
 }
@@ -74,12 +78,17 @@ proc dg-pph-pos { subdir test options ma
     set dg-do-what-default compile
     dg-test -keep-output $test "$options -I." ""
 
-    # Determine whether this is an executable test
+    # Determine whether this is an assembly comparison test
     set is_exec [llength [grep $test "dg-do run"]]
+    set is_link [llength [grep $test "dg-do link"]]
+    if { !$is_exec && !$is_link } {
+        set is_asm 1
+    } else {
+        set is_asm 0
+    }
 
-    # Executables do not generate assembly.
-    if { !$is_exec } {
-	# Not executable, so quit if it did not compile successfully.
+    if { $is_asm } {
+	# Wanted assembly, so quit if it did not compile successfully.
 	if { ![file_on_host exists "$bname.s"] } {
 	    fail "$nshort $options (regular assembly missing)"
 	    return
@@ -95,8 +104,8 @@ proc dg-pph-pos { subdir test options ma
     # Compile a second time using the pph files.
     dg-test -keep-output $test "$options $mapflag -I." ""
 
-    # Executables do not generate assembly,
-    if { $is_exec } {
+    if { !$is_asm } {
+	# No assembly means we cannot compare them,
 	# and so we are done testing.
 	return
     }
Index: gcc/testsuite/g++.dg/pph/x6dynarray3.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/x6dynarray3.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/x6dynarray3.cc	(working copy)
@@ -1,4 +1,5 @@
-// { dg-do run }
+// { dg-xfail-if "ICE" { "*-*-*" } { "-fpph-map=pph.map" } }
+// { dg-bogus "x6dynarray3.cc:1:0: internal compiler error: in chainon, at tree.c:2165" "" { xfail *-*-* } 0 }
 
 #include "x5dynarray3.h"
 
Index: gcc/testsuite/g++.dg/pph/c4meteor-contest.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/c4meteor-contest.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c4meteor-contest.cc	(working copy)
@@ -1,7 +1,7 @@
 /* { dg-options "-w" }  */
 // pph asm xdiff
 
-#include "c4meteor-contest.h"
+#include "p4meteor-contest.h"
 
 int main(int argc, char **argv) {
    if(argc > 1)
Index: gcc/testsuite/g++.dg/pph/c4eabi1.h
===================================================================
--- gcc/testsuite/g++.dg/pph/c4eabi1.h	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c4eabi1.h	(working copy)
@@ -1,161 +0,0 @@
-// { dg-options "-w -fpermissive" }
-// FIXME pph - Enabling PPH for this file causes memory problems in cc1plus.
-// c1eabi1.h	c1eabi1.pph
-
-#ifndef C4EABI1_H
-#define C4EABI1_H
-
-/* This file tests most of the non-C++ run-time helper functions
-   described in Section 4 of the "Run-Time ABI for the ARM
-   Architecture".  These are basic tests; they do not try to validate
-   all of the corner cases in these routines.  
-
-   The functions not tested here are:
-
-     __aeabi_cdcmpeq
-     __aeabi_cdcmple
-     __aeabi_cdrcmple
-     __aeabi_cfcmpeq
-     __aeabi_cfcmple
-     __aeabi_cfrcmple
-     __aeabi_ldivmod
-     __aeabi_uldivmod
-     __aeabi_idivmod
-     __aeabi_uidivmod
-
-   These functions have non-standard calling conventions that would
-   require the use of inline assembly to test.  It would be good to
-   add such tests, but they have not yet been implemented.  
-
-   There are also no tests for the "division by zero", "memory copying,
-   clearing, and setting" functions.  */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-/* All these functions are defined to use the base ABI, so use the
-   attribute to ensure the tests use the base ABI to call them even
-   when the VFP ABI is otherwise in effect.  */
-#define PCS __attribute__((pcs("aapcs")))
-
-#define decl_float(code, type)						\
-  extern type __aeabi_ ## code ## add (type, type) PCS;			\
-  extern type __aeabi_ ## code ## div (type, type) PCS;			\
-  extern type __aeabi_ ## code ## mul (type, type) PCS;			\
-  extern type __aeabi_ ## code ## neg (type) PCS;			\
-  extern type __aeabi_ ## code ## rsub (type, type) PCS;		\
-  extern type __aeabi_ ## code ## sub (type, type) PCS;			\
-  extern int __aeabi_ ## code ## cmpeq (type, type) PCS;		\
-  extern int __aeabi_ ## code ## cmplt (type, type) PCS;		\
-  extern int __aeabi_ ## code ## cmple (type, type) PCS;		\
-  extern int __aeabi_ ## code ## cmpge (type, type) PCS;		\
-  extern int __aeabi_ ## code ## cmpgt (type, type) PCS;		\
-  extern int __aeabi_ ## code ## cmpun (type, type) PCS;		\
-  extern int __aeabi_ ## code ## 2iz (type) PCS;			\
-  extern unsigned int __aeabi_ ## code ## 2uiz (type) PCS;		\
-  extern long long __aeabi_ ## code ## 2lz (type) PCS;			\
-  extern unsigned long long __aeabi_ ## code ## 2ulz (type) PCS;	\
-  extern type __aeabi_i2 ## code (int) PCS;				\
-  extern type __aeabi_ui2 ## code (int) PCS;				\
-  extern type __aeabi_l2 ## code (long long) PCS;			\
-  extern type __aeabi_ul2 ## code (unsigned long long) PCS;		\
-									\
-  type code ## zero = 0.0;						\
-  type code ## one = 1.0;						\
-  type code ## two = 2.0;						\
-  type code ## four = 4.0;						\
-  type code ## minus_one = -1.0;					\
-  type code ## minus_two = -2.0;					\
-  type code ## minus_four = -4.0;					\
-  type code ## epsilon = 1E-32;						\
-  type code ## NaN = 0.0 / 0.0;
-
-decl_float (d, double)
-decl_float (f, float)
-
-extern float __aeabi_d2f (double) PCS;
-extern double __aeabi_f2d (float) PCS;
-extern long long __aeabi_lmul (long long, long long);
-extern long long __aeabi_llsl (long long, int);
-extern long long __aeabi_llsr (long long, int);
-extern long long __aeabi_lasr (long long, int);
-extern int __aeabi_lcmp (long long, long long);
-extern int __aeabi_ulcmp (unsigned long long, unsigned long long);
-extern int __aeabi_idiv (int, int);
-extern unsigned int __aeabi_uidiv (unsigned int, unsigned int);
-extern int __aeabi_uread4 (void *);
-extern int __aeabi_uwrite4 (int, void *);
-extern long long __aeabi_uread8 (void *);
-extern long long __aeabi_uwrite8 (long long, void *);
-
-#define eq(a, b, type, abs, epsilon, format)			\
-  {								\
-    type a1;							\
-    type b1;							\
-								\
-    a1 = a;							\
-    b1 = b;							\
-    if (abs (a1 - b1) > epsilon)				\
-    {								\
-      fprintf (stderr, "%d: Test %s == %s\n", __LINE__, #a, #b);	\
-      fprintf (stderr, "%d: " format " != " format "\n",	\
-	       __LINE__, a1, b1);				\
-      abort ();							\
-    }								\
-  }
-
-#define ieq(a, b) eq (a, b, int, abs, 0, "%d")
-#define ueq(a, b) eq (a, b, unsigned int, abs, 0, "%u")
-#define leq(a, b) eq (a, b, long long, abs, 0, "%lld")
-#define uleq(a, b) eq (a, b, unsigned long long, abs, 0, "%llu")
-#define feq(a, b) eq (a, b, float, fabs, fepsilon, "%f")
-#define deq(a, b) eq (a, b, double, fabs, depsilon, "%g")
-
-#define NUM_CMP_VALUES 6
-
-/* Values picked to cover a range of small, large, positive and negative.  */
-static unsigned int cmp_val[NUM_CMP_VALUES] = 
-{
-  0,
-  1,
-  0x40000000,
-  0x80000000,
-  0xc0000000,
-  0xffffffff
-};
-
-/* All combinations for each of the above values. */
-#define ulcmp(l, s, m) \
-    s, l, l, l, l, l,  m, s, l, l, l, l, \
-    m, m, s, l, l, l,  m, m, m, s, l, l, \
-    m, m, m, m, s, l,  m, m, m, m, m, s
-
-#define lcmp(l, s, m) \
-    s, l, l, m, m, m,  m, s, l, m, m, m, \
-    m, m, s, m, m, m,  l, l, l, s, l, l, \
-    l, l, l, m, s, l,  l, l, l, m, m, s
-
-/* All combinations of the above for high/low words.  */
-static int lcmp_results[] =
-{
-  lcmp(ulcmp(-1, -1, -1), ulcmp(-1, 0, 1), ulcmp(1, 1, 1))
-};
-
-static int ulcmp_results[] =
-{
-  ulcmp(ulcmp(-1, -1, -1), ulcmp(-1, 0, 1), ulcmp(1, 1, 1))
-};
-
-static int signof(int i)
-{
-  if (i < 0)
-    return -1;
-
-  if (i == 0)
-    return 0;
-
-  return 1;
-}
-
-#endif
Index: gcc/testsuite/g++.dg/pph/c4pr36533.h
===================================================================
--- gcc/testsuite/g++.dg/pph/c4pr36533.h	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c4pr36533.h	(working copy)
@@ -1,16 +0,0 @@
-/* PR target/36533 */
-/* { dg-options "-w -fpermissive" } */
-
-#ifndef C4PR36533_H
-#define C4PR36533_H
-
-#include <sys/mman.h>
-#include <string.h>
-
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#include "a0pr36533.h"
-
-#endif
Index: gcc/testsuite/g++.dg/pph/p4pr36533.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/p4pr36533.cc	(revision 176187)
+++ gcc/testsuite/g++.dg/pph/p4pr36533.cc	(working copy)
@@ -1,3 +1,2 @@
 /* { dg-options "-w -fpermissive" } */
-// pph asm xdiff
-#include "c4pr36533.h"
+#include "p4pr36533.h"
Index: gcc/testsuite/g++.dg/pph/pph.exp
===================================================================
--- gcc/testsuite/g++.dg/pph/pph.exp	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/pph.exp	(working copy)
@@ -29,11 +29,17 @@ dg-init
 # FIXME set scenarios [list "" "-g" "-O"]
 set scenarios [list "" ]
 
-set hdr_tests [lsort [glob -nocomplain $srcdir/$subdir/\[cdx\]*.h]]
+set hdr_tests [lsort [glob -nocomplain $srcdir/$subdir/\[cdpxy\]*.h]]
 set neg_tests [lsort [glob -nocomplain $srcdir/$subdir/\[dy\]*.cc]]
 set pos_tests [lsort [glob -nocomplain $srcdir/$subdir/\[cpx\]*.cc]]
 
-gcc_copy_files $srcdir/$subdir/pph.map .
+exec ls $srcdir/$subdir | sed -e /^\[cpdxy\].*\.h$/!d -e s/.*/&\t&/ -e s/\.h$/\.pph/ > pph.map
+exec echo "math.h	math.pph" >> pph.map
+exec echo "stdio.h	stdio.pph" >> pph.map
+exec echo "stdlib.h	stdlib.pph" >> pph.map
+exec echo "string.h	string.pph" >> pph.map
+exec echo "sys/types.h	types.pph" >> pph.map
+
 set mapflag -fpph-map=pph.map
 
 foreach scenario $scenarios {
Index: gcc/testsuite/g++.dg/pph/c4pr36533.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/c4pr36533.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c4pr36533.cc	(working copy)
@@ -1,2 +0,0 @@
-/* { dg-options "-w -fpermissive" } */
-#include "c4pr36533.h"
Index: gcc/testsuite/g++.dg/pph/pph.map
===================================================================
--- gcc/testsuite/g++.dg/pph/pph.map	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/pph.map	(working copy)
@@ -1,67 +0,0 @@
-c0-20060625-1.h	c0-20060625-1.pph
-c0altinc1.h	c0altinc1.pph
-c3altinc2.h	c3altinc2.pph
-c0attr-warn-unused.h	c0attr-warn-unused.pph
-c0builtin-integral.h	c0builtin-integral.pph
-c0builtin-objsize.h	c0builtin-objsize.pph
-c0chained1.h	c0chained1.pph
-c0chained2.h	c0chained2.pph
-c1eabi1.h	c1eabi1.pph
-c0empty.h	c0empty.pph
-c0field.h	c0field.pph
-c0funcmac.h	c0funcmac.pph
-c0funcstatic.h	c0funcstatic.pph
-c0functions.h	c0functions.pph
-c0guarded1.h	c0guarded1.pph
-c1guarded2.h	c1guarded2.pph
-c1guarded3.h	c1guarded3.pph
-c0limits-externalid.h	c0limits-externalid.pph
-c0meteor-contest.h	c0meteor-contest.pph
-c0multinc1.h	c0multinc1.pph
-c1multinc2.h	c1multinc2.pph
-c1pr36533.h	c1pr36533.pph
-c0pr44948-1a.h	c0pr44948-1a.pph
-c0return-5.h	c0return-5.pph
-c0simple1.h	c0simple1.pph
-c1simple2.h	c1simple2.pph
-c0struct.h	c0struct.pph
-c0typerefs.h	c0typerefs.pph
-c0variables.h	c0variables.pph
-c0varorder.h	c0varorder.pph
-c0builtin1.h	c0builtin1.pph
-c1builtin2.h	c1builtin2.pph
-c1builtin3.h	c1builtin3.pph
-c0builtin5.h	c0builtin5.pph
-c0builtin6.h	c0builtin6.pph
-c0dupguard1.h	c0dupguard1.pph
-c0dupguard2.h	c0dupguard2.pph
-c4eabi1.h	c4eabi1.pph
-c4meteor-contest.h	c4meteor-contest.pph
-c0paste.h	c0paste.pph
-d0symnotinc.h	d0symnotinc.pph
-math.h	math.pph
-stdio.h	stdio.pph
-stdlib.h	stdlib.pph
-string.h	string.pph
-sys/types.h	types.pph
-x0autometh.h	x0autometh.pph
-x0dynarray1.h	x0dynarray1.pph
-x1funcstatic.h	x1funcstatic.pph
-x1functions.h	x1functions.pph
-x0globalref.h	x0globalref.pph
-x0hardlookup.h	x0hardlookup.pph
-x0namespace.h	x0namespace.pph
-x0special.h	x0special.pph
-x0struct0.h	x0struct0.pph
-x1struct1.h	x1struct1.pph
-x1struct2.h	x1struct2.pph
-x0template.h	x0template.pph
-x0ten-hellos.h	x0ten-hellos.pph
-x0tmplclass.h	x0tmplclass.pph
-x0tmplfunc.h	x0tmplfunc.pph
-x1typerefs.h	x1typerefs.pph
-x1variables.h	x1variables.pph
-x0nontrivinit.h	x0nontrivinit.pph
-x0overload1.h	x0overload1.pph
-x0overload2.h	x0overload2.pph
-x1overload3.h	x1overload3.pph
Index: gcc/testsuite/g++.dg/pph/p4eabi1.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/p4eabi1.cc	(revision 176187)
+++ gcc/testsuite/g++.dg/pph/p4eabi1.cc	(working copy)
@@ -1,7 +1,7 @@
 // { dg-options "-w -fpermissive" }
 // pph asm xdiff
 
-#include "c4eabi1.h"
+#include "p4eabi1.h"
 
 int main () {
   unsigned char bytes[256];
Index: gcc/testsuite/g++.dg/pph/x6dynarray4.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/x6dynarray4.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/x6dynarray4.cc	(working copy)
@@ -1,5 +1,6 @@
 // { dg-xfail-if "BOGUS" { "*-*-*" } { "-fpph-map=pph.map" } }
-// { dg-bogus "cstdlib:42:0: error: PPH file stdlib.pph fails macro validation, __STDDEF_H__" "" { xfail *-*-* } 0 }
+// { dg-bogus "error: Cannot open PPH file for reading: x6dynarray5.pph: No such file or directory" "" { xfail *-*-* } 0 }
+// { dg-prune-output "In file included from" }
 
 #include "x6dynarray5.h"
 
Index: gcc/testsuite/g++.dg/pph/x1dynarray2a.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/x1dynarray2a.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/x1dynarray2a.cc	(working copy)
@@ -1,4 +1,5 @@
-// { dg-do run }
+// { dg-xfail-if "BOGUS" { "*-*-*" } { "-fpph-map=pph.map" } }
+// { dg-do link }
 
 #include "x0dynarray2.h"
 
Index: gcc/testsuite/g++.dg/pph/c0meteor-contest.h
===================================================================
--- gcc/testsuite/g++.dg/pph/c0meteor-contest.h	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c0meteor-contest.h	(working copy)
@@ -36,7 +36,7 @@ POSSIBILITY OF SUCH DAMAGE.
  * contributed by Christian Vosteen
  */
 
-/* Simplified version of c4meteor-contest.h
+/* Simplified version of p4meteor-contest.h
    - Do not include other system headers here.
    Simply forward declare the library functions used by this header.  */
 extern  "C" {
Index: gcc/testsuite/g++.dg/pph/c4meteor-contest.h
===================================================================
--- gcc/testsuite/g++.dg/pph/c4meteor-contest.h	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c4meteor-contest.h	(working copy)
@@ -1,617 +0,0 @@
-/* { dg-options "-w" }  */
-#ifndef C4METEOR_CONTEST_H
-#define C4METEOR_CONTEST_H
-/*
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
-    * Neither the name of "The Computer Language Benchmarks Game" nor the
-    name of "The Computer Language Shootout Benchmarks" nor the names of
-    its contributors may be used to endorse or promote products derived
-    from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
-*/
-
-/* The Computer Language Benchmarks Game
- * http://shootout.alioth.debian.org/
- *
- * contributed by Christian Vosteen
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#define TRUE 1
-#define FALSE 0
-
-/* The board is a 50 cell hexagonal pattern.  For    . . . . .
- * maximum speed the board will be implemented as     . . . . .
- * 50 bits, which will fit into a 64 bit long long   . . . . .
- * int.                                               . . . . .
- *                                                   . . . . .
- * I will represent 0's as empty cells and 1's        . . . . .
- * as full cells.                                    . . . . .
- *                                                    . . . . .
- *                                                   . . . . .
- *                                                    . . . . .
- */
-
-unsigned long long board = 0xFFFC000000000000ULL;
-
-/* The puzzle pieces must be specified by the path followed
- * from one end to the other along 12 hexagonal directions.
- *
- *   Piece 0   Piece 1   Piece 2   Piece 3   Piece 4
- *
- *  O O O O    O   O O   O O O     O O O     O   O
- *         O    O O           O       O       O O
- *                           O         O         O
- *
- *   Piece 5   Piece 6   Piece 7   Piece 8   Piece 9
- *
- *    O O O     O O       O O     O O        O O O O
- *       O O       O O       O       O O O        O
- *                  O       O O
- *
- * I had to make it 12 directions because I wanted all of the
- * piece definitions to fit into the same size arrays.  It is
- * not possible to define piece 4 in terms of the 6 cardinal
- * directions in 4 moves.
- */
-
-#define E     0
-#define ESE   1
-#define SE    2
-#define S     3
-#define SW    4
-#define WSW   5
-#define W     6
-#define WNW   7
-#define NW    8
-#define N     9
-#define NE    10
-#define ENE   11
-#define PIVOT 12
-
-char piece_def[10][4] = {
-   {  E,  E,  E, SE},
-   { SE,  E, NE,  E},
-   {  E,  E, SE, SW},
-   {  E,  E, SW, SE},
-   { SE,  E, NE,  S},
-   {  E,  E, SW,  E},
-   {  E, SE, SE, NE},
-   {  E, SE, SE,  W},
-   {  E, SE,  E,  E},
-   {  E,  E,  E, SW}
-};
-
-
-/* To minimize the amount of work done in the recursive solve function below,
- * I'm going to allocate enough space for all legal rotations of each piece
- * at each position on the board. That's 10 pieces x 50 board positions x
- * 12 rotations.  However, not all 12 rotations will fit on every cell, so
- * I'll have to keep count of the actual number that do.
- * The pieces are going to be unsigned long long ints just like the board so
- * they can be bitwise-anded with the board to determine if they fit.
- * I'm also going to record the next possible open cell for each piece and
- * location to reduce the burden on the solve function.
- */
-unsigned long long pieces[10][50][12];
-int piece_counts[10][50];
-char next_cell[10][50][12];
-
-/* Returns the direction rotated 60 degrees clockwise */
-char rotate(char dir) {
-   return (dir + 2) % PIVOT;
-}
-
-/* Returns the direction flipped on the horizontal axis */
-char flip(char dir) {
-   return (PIVOT - dir) % PIVOT;
-}
-
-
-/* Returns the new cell index from the specified cell in the
- * specified direction.  The index is only valid if the
- * starting cell and direction have been checked by the
- * out_of_bounds function first.
- */
-char shift(char cell, char dir) {
-   switch(dir) {
-      case E:
-         return cell + 1;
-      case ESE:
-         if((cell / 5) % 2)
-            return cell + 7;
-         else
-            return cell + 6;
-      case SE:
-         if((cell / 5) % 2)
-            return cell + 6;
-         else
-            return cell + 5;
-      case S:
-         return cell + 10;
-      case SW:
-         if((cell / 5) % 2)
-            return cell + 5;
-         else
-            return cell + 4;
-      case WSW:
-         if((cell / 5) % 2)
-            return cell + 4;
-         else
-            return cell + 3;
-      case W:
-         return cell - 1;
-      case WNW:
-         if((cell / 5) % 2)
-            return cell - 6;
-         else
-            return cell - 7;
-      case NW:
-         if((cell / 5) % 2)
-            return cell - 5;
-         else
-            return cell - 6;
-      case N:
-         return cell - 10;
-      case NE:
-         if((cell / 5) % 2)
-            return cell - 4;
-         else
-            return cell - 5;
-      case ENE:
-         if((cell / 5) % 2)
-            return cell - 3;
-         else
-            return cell - 4;
-      default:
-         return cell;
-   }
-}
-
-/* Returns wether the specified cell and direction will land outside
- * of the board.  Used to determine if a piece is at a legal board
- * location or not.
- */
-char out_of_bounds(char cell, char dir) {
-   char i;
-   switch(dir) {
-      case E:
-         return cell % 5 == 4;
-      case ESE:
-         i = cell % 10;
-         return i == 4 || i == 8 || i == 9 || cell >= 45;
-      case SE:
-         return cell % 10 == 9 || cell >= 45;
-      case S:
-         return cell >= 40;
-      case SW:
-         return cell % 10 == 0 || cell >= 45;
-      case WSW:
-         i = cell % 10;
-         return i == 0 || i == 1 || i == 5 || cell >= 45;
-      case W:
-         return cell % 5 == 0;
-      case WNW:
-         i = cell % 10;
-         return i == 0 || i == 1 || i == 5 || cell < 5;
-      case NW:
-         return cell % 10 == 0 || cell < 5;
-      case N:
-         return cell < 10;
-      case NE:
-         return cell % 10 == 9 || cell < 5;
-      case ENE:
-         i = cell % 10;
-         return i == 4 || i == 8 || i == 9 || cell < 5;
-      default:
-         return FALSE;
-   }
-}
-
-/* Rotate a piece 60 degrees clockwise */
-void rotate_piece(int piece) {
-   int i;
-   for(i = 0; i < 4; i++)
-      piece_def[piece][i] = rotate(piece_def[piece][i]);
-}
-
-/* Flip a piece along the horizontal axis */
-void flip_piece(int piece) {
-   int i;
-   for(i = 0; i < 4; i++)
-      piece_def[piece][i] = flip(piece_def[piece][i]);
-}
-
-/* Convenience function to quickly calculate all of the indices for a piece */
-void calc_cell_indices(char *cell, int piece, char index) {
-   cell[0] = index;
-   cell[1] = shift(cell[0], piece_def[piece][0]);
-   cell[2] = shift(cell[1], piece_def[piece][1]);
-   cell[3] = shift(cell[2], piece_def[piece][2]);
-   cell[4] = shift(cell[3], piece_def[piece][3]);
-}
-
-/* Convenience function to quickly calculate if a piece fits on the board */
-int cells_fit_on_board(char *cell, int piece) {
-   return (!out_of_bounds(cell[0], piece_def[piece][0]) &&
-         !out_of_bounds(cell[1], piece_def[piece][1]) &&
-         !out_of_bounds(cell[2], piece_def[piece][2]) &&
-         !out_of_bounds(cell[3], piece_def[piece][3]));
-}
-
-/* Returns the lowest index of the cells of a piece.
- * I use the lowest index that a piece occupies as the index for looking up
- * the piece in the solve function.
- */
-char minimum_of_cells(char *cell) {
-   char minimum = cell[0];
-   minimum = cell[1] < minimum ? cell[1] : minimum;
-   minimum = cell[2] < minimum ? cell[2] : minimum;
-   minimum = cell[3] < minimum ? cell[3] : minimum;
-   minimum = cell[4] < minimum ? cell[4] : minimum;
-   return minimum;
-}
-
-/* Calculate the lowest possible open cell if the piece is placed on the board.
- * Used to later reduce the amount of time searching for open cells in the
- * solve function.
- */
-char first_empty_cell(char *cell, char minimum) {
-   char first_empty = minimum;
-   while(first_empty == cell[0] || first_empty == cell[1] ||
-         first_empty == cell[2] || first_empty == cell[3] ||
-         first_empty == cell[4])
-      first_empty++;
-   return first_empty;
-}
-
-/* Generate the unsigned long long int that will later be anded with the
- * board to determine if it fits.
- */
-unsigned long long bitmask_from_cells(char *cell) {
-   unsigned long long piece_mask = 0ULL;
-   int i;
-   for(i = 0; i < 5; i++)
-      piece_mask |= 1ULL << cell[i];
-   return piece_mask;
-}
-
-/* Record the piece and other important information in arrays that will
- * later be used by the solve function.
- */
-void record_piece(int piece, int minimum, char first_empty,
-      unsigned long long piece_mask) {
-   pieces[piece][minimum][piece_counts[piece][minimum]] = piece_mask;
-   next_cell[piece][minimum][piece_counts[piece][minimum]] = first_empty;
-   piece_counts[piece][minimum]++;
-}
-
-
-/* Fill the entire board going cell by cell.  If any cells are "trapped"
- * they will be left alone.
- */
-void fill_contiguous_space(char *board, int index) {
-   if(board[index] == 1)
-      return;
-   board[index] = 1;
-   if(!out_of_bounds(index, E))
-      fill_contiguous_space(board, shift(index, E));
-   if(!out_of_bounds(index, SE))
-      fill_contiguous_space(board, shift(index, SE));
-   if(!out_of_bounds(index, SW))
-      fill_contiguous_space(board, shift(index, SW));
-   if(!out_of_bounds(index, W))
-      fill_contiguous_space(board, shift(index, W));
-   if(!out_of_bounds(index, NW))
-      fill_contiguous_space(board, shift(index, NW));
-   if(!out_of_bounds(index, NE))
-      fill_contiguous_space(board, shift(index, NE));
-}
-
-
-/* To thin the number of pieces, I calculate if any of them trap any empty
- * cells at the edges.  There are only a handful of exceptions where the
- * the board can be solved with the trapped cells.  For example:  piece 8 can
- * trap 5 cells in the corner, but piece 3 can fit in those cells, or piece 0
- * can split the board in half where both halves are viable.
- */
-int has_island(char *cell, int piece) {
-   char temp_board[50];
-   char c;
-   int i;
-   for(i = 0; i < 50; i++)
-      temp_board[i] = 0;
-   for(i = 0; i < 5; i++)
-      temp_board[((int)cell[i])] = 1;
-   i = 49;
-   while(temp_board[i] == 1)
-      i--;
-   fill_contiguous_space(temp_board, i);
-   c = 0;
-   for(i = 0; i < 50; i++)
-      if(temp_board[i] == 0)
-         c++;
-   if(c == 0 || (c == 5 && piece == 8) || (c == 40 && piece == 8) ||
-         (c % 5 == 0 && piece == 0))
-      return FALSE;
-   else
-      return TRUE;
-}
-
-
-/* Calculate all six rotations of the specified piece at the specified index.
- * We calculate only half of piece 3's rotations.  This is because any solution
- * found has an identical solution rotated 180 degrees.  Thus we can reduce the
- * number of attempted pieces in the solve algorithm by not including the 180-
- * degree-rotated pieces of ONE of the pieces.  I chose piece 3 because it gave
- * me the best time ;)
- */
- void calc_six_rotations(char piece, char index) {
-   char rotation, cell[5];
-   char minimum, first_empty;
-   unsigned long long piece_mask;
-
-   for(rotation = 0; rotation < 6; rotation++) {
-      if(piece != 3 || rotation < 3) {
-         calc_cell_indices(cell, piece, index);
-         if(cells_fit_on_board(cell, piece) && !has_island(cell, piece)) {
-            minimum = minimum_of_cells(cell);
-            first_empty = first_empty_cell(cell, minimum);
-            piece_mask = bitmask_from_cells(cell);
-            record_piece(piece, minimum, first_empty, piece_mask);
-         }
-      }
-      rotate_piece(piece);
-   }
-}
-
-/* Calculate every legal rotation for each piece at each board location. */
-void calc_pieces(void) {
-   char piece, index;
-
-   for(piece = 0; piece < 10; piece++) {
-      for(index = 0; index < 50; index++) {
-         calc_six_rotations(piece, index);
-         flip_piece(piece);
-         calc_six_rotations(piece, index);
-      }
-   }
-}
-
-
-
-/* Calculate all 32 possible states for a 5-bit row and all rows that will
- * create islands that follow any of the 32 possible rows.  These pre-
- * calculated 5-bit rows will be used to find islands in a partially solved
- * board in the solve function.
- */
-#define ROW_MASK 0x1F
-#define TRIPLE_MASK 0x7FFF
-char all_rows[32] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-      17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
-int bad_even_rows[32][32];
-int bad_odd_rows[32][32];
-int bad_even_triple[32768];
-int bad_odd_triple[32768];
-
-int rows_bad(char row1, char row2, int even) {
-   /* even is referring to row1 */
-   int i, in_zeroes, group_okay;
-   char block, row2_shift;
-   /* Test for blockages at same index and shifted index */
-   if(even)
-      row2_shift = ((row2 << 1) & ROW_MASK) | 0x01;
-   else
-      row2_shift = (row2 >> 1) | 0x10;
-   block = ((row1 ^ row2) & row2) & ((row1 ^ row2_shift) & row2_shift);
-   /* Test for groups of 0's */
-   in_zeroes = FALSE;
-   group_okay = FALSE;
-   for(i = 0; i < 5; i++) {
-      if(row1 & (1 << i)) {
-         if(in_zeroes) {
-            if(!group_okay)
-               return TRUE;
-            in_zeroes = FALSE;
-            group_okay = FALSE;
-         }
-      } else {
-         if(!in_zeroes)
-            in_zeroes = TRUE;
-         if(!(block & (1 << i)))
-            group_okay = TRUE;
-      }
-   }
-   if(in_zeroes)
-      return !group_okay;
-   else
-      return FALSE;
-}
-
-/* Check for cases where three rows checked sequentially cause a false
- * positive.  One scenario is when 5 cells may be surrounded where piece 5
- * or 7 can fit.  The other scenario is when piece 2 creates a hook shape.
- */
-int triple_is_okay(char row1, char row2, char row3, int even) {
-   if(even) {
-      /* There are four cases:
-       * row1: 00011  00001  11001  10101
-       * row2: 01011  00101  10001  10001
-       * row3: 011??  00110  ?????  ?????
-       */
-      return ((row1 == 0x03) && (row2 == 0x0B) && ((row3 & 0x1C) == 0x0C)) ||
-            ((row1 == 0x01) && (row2 == 0x05) && (row3 == 0x06)) ||
-            ((row1 == 0x19) && (row2 == 0x11)) ||
-            ((row1 == 0x15) && (row2 == 0x11));
-   } else {
-      /* There are two cases:
-       * row1: 10011  10101
-       * row2: 10001  10001
-       * row3: ?????  ?????
-       */
-      return ((row1 == 0x13) && (row2 == 0x11)) ||
-            ((row1 == 0x15) && (row2 == 0x11));
-   }
-}
-
-
-void calc_rows(void) {
-   int row1, row2, row3;
-   int result1, result2;
-   for(row1 = 0; row1 < 32; row1++) {
-      for(row2 = 0; row2 < 32; row2++) {
-         bad_even_rows[row1][row2] = rows_bad(row1, row2, TRUE);
-         bad_odd_rows[row1][row2] = rows_bad(row1, row2, FALSE);
-      }
-   }
-   for(row1 = 0; row1 < 32; row1++) {
-      for(row2 = 0; row2 < 32; row2++) {
-         for(row3 = 0; row3 < 32; row3++) {
-            result1 = bad_even_rows[row1][row2];
-            result2 = bad_odd_rows[row2][row3];
-            if(result1 == FALSE && result2 == TRUE
-                  && triple_is_okay(row1, row2, row3, TRUE))
-               bad_even_triple[row1+(row2*32)+(row3*1024)] = FALSE;
-            else
-               bad_even_triple[row1+(row2*32)+(row3*1024)] = result1 || result2;
-
-            result1 = bad_odd_rows[row1][row2];
-            result2 = bad_even_rows[row2][row3];
-            if(result1 == FALSE && result2 == TRUE
-                  && triple_is_okay(row1, row2, row3, FALSE))
-               bad_odd_triple[row1+(row2*32)+(row3*1024)] = FALSE;
-            else
-               bad_odd_triple[row1+(row2*32)+(row3*1024)] = result1 || result2;
-         }
-      }
-   }
-}
-
-
-
-/* Calculate islands while solving the board.
- */
-int boardHasIslands(char cell) {
-   /* Too low on board, don't bother checking */
-   if(cell >= 40)
-      return FALSE;
-   int current_triple = (board >> ((cell / 5) * 5)) & TRIPLE_MASK;
-   if((cell / 5) % 2)
-      return bad_odd_triple[current_triple];
-   else
-      return bad_even_triple[current_triple];
-}
-
-
-/* The recursive solve algorithm.  Try to place each permutation in the upper-
- * leftmost empty cell.  Mark off available pieces as it goes along.
- * Because the board is a bit mask, the piece number and bit mask must be saved
- * at each successful piece placement.  This data is used to create a 50 char
- * array if a solution is found.
- */
-short avail = 0x03FF;
-char sol_nums[10];
-unsigned long long sol_masks[10];
-signed char solutions[2100][50];
-int solution_count = 0;
-int max_solutions = 2100;
-
-void record_solution(void) {
-   int sol_no, index;
-   unsigned long long sol_mask;
-   for(sol_no = 0; sol_no < 10; sol_no++) {
-      sol_mask = sol_masks[sol_no];
-      for(index = 0; index < 50; index++) {
-         if(sol_mask & 1ULL) {
-            solutions[solution_count][index] = sol_nums[sol_no];
-            /* Board rotated 180 degrees is a solution too! */
-            solutions[solution_count+1][49-index] = sol_nums[sol_no];
-         }
-         sol_mask = sol_mask >> 1;
-      }
-   }
-   solution_count += 2;
-}
-
-void solve(int depth, int cell) {
-   int piece, rotation, max_rots;
-   unsigned long long *piece_mask;
-   short piece_no_mask;
-
-   if(solution_count >= max_solutions)
-      return;
-
-   while(board & (1ULL << cell))
-      cell++;
-
-   for(piece = 0; piece < 10; piece++) {
-      piece_no_mask = 1 << piece;
-      if(!(avail & piece_no_mask))
-         continue;
-      avail ^= piece_no_mask;
-      max_rots = piece_counts[piece][cell];
-      piece_mask = pieces[piece][cell];
-      for(rotation = 0; rotation < max_rots; rotation++) {
-         if(!(board & *(piece_mask + rotation))) {
-            sol_nums[depth] = piece;
-            sol_masks[depth] = *(piece_mask + rotation);
-            if(depth == 9) {
-               /* Solution found!!!!!11!!ONE! */
-               record_solution();
-               avail ^= piece_no_mask;
-               return;
-            }
-            board |= *(piece_mask + rotation);
-            if(!boardHasIslands(next_cell[piece][cell][rotation]))
-               solve(depth + 1, next_cell[piece][cell][rotation]);
-            board ^= *(piece_mask + rotation);
-         }
-      }
-      avail ^= piece_no_mask;
-   }
-}
-
-
-/* qsort comparator - used to find first and last solutions */
-int solution_sort(const void *elem1, const void *elem2) {
-   signed char *char1 = (signed char *) elem1;
-   signed char *char2 = (signed char *) elem2;
-   int i = 0;
-   while(i < 50 && char1[i] == char2[i])
-      i++;
-   return char1[i] - char2[i];
-}
-
-
-/* pretty print a board in the specified hexagonal format */
-void pretty(signed char *b) {
-   int i;
-   for(i = 0; i < 50; i += 10) {
-      printf("%c %c %c %c %c \n %c %c %c %c %c \n", b[i]+'0', b[i+1]+'0',
-            b[i+2]+'0', b[i+3]+'0', b[i+4]+'0', b[i+5]+'0', b[i+6]+'0',
-            b[i+7]+'0', b[i+8]+'0', b[i+9]+'0');
-   }
-   printf("\n");
-}
-#endif
Index: gcc/testsuite/g++.dg/pph/p2pr36533.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/p2pr36533.cc	(revision 176187)
+++ gcc/testsuite/g++.dg/pph/p2pr36533.cc	(working copy)
@@ -1,3 +1,2 @@
 /* { dg-options "-w -fpermissive" } */
-// pph asm xdiff
-#include "c1pr36533.h"
+#include "p1pr36533.h"
Index: gcc/testsuite/g++.dg/pph/x6dynarray5.h
===================================================================
--- gcc/testsuite/g++.dg/pph/x6dynarray5.h	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/x6dynarray5.h	(working copy)
@@ -1,3 +1,6 @@
+// { dg-xfail-if "BOGUS" { "*-*-*" } { "-fpph-map=pph.map" } }
+// { dg-bogus "a0dynarray-dfn1b.hi:3:19: error: there are no arguments to 'alloc' that depend on a template parameter, so a declaration of 'alloc' must be available" "" { xfail *-*-* } 0 }
+
 #ifndef X6DYNARRAY5_H
 #define X6DYNARRAY5_H
 
Index: gcc/testsuite/g++.dg/pph/c1eabi1.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/c1eabi1.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c1eabi1.cc	(working copy)
@@ -1,4 +1,5 @@
 // { dg-options "-w -fpermissive" }
+// pph asm xdiff
 
 #include "c0eabi1.h"
 
Index: gcc/testsuite/g++.dg/pph/c4eabi1.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/c4eabi1.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c4eabi1.cc	(working copy)
@@ -1,191 +0,0 @@
-// { dg-options "-w -fpermissive" }
-// pph asm xdiff
-
-#include "c4eabi1.h"
-
-int main () {
-  unsigned char bytes[256];
-  int i, j, k, n;
-  int *result;
-
-  /* Table 2.  Double-precision floating-point arithmetic.  */
-  deq (__aeabi_dadd (dzero, done), done);
-  deq (__aeabi_dadd (done, done), dtwo);
-  deq (__aeabi_ddiv (dminus_four, dminus_two), dtwo);
-  deq (__aeabi_ddiv (dminus_two, dtwo), dminus_one);
-  deq (__aeabi_dmul (dtwo, dtwo), dfour);
-  deq (__aeabi_dmul (dminus_one, dminus_two), dtwo);
-  deq (__aeabi_dneg (dminus_one), done);
-  deq (__aeabi_dneg (dfour), dminus_four);
-  deq (__aeabi_drsub (done, dzero), dminus_one);
-  deq (__aeabi_drsub (dtwo, dminus_two), dminus_four);
-  deq (__aeabi_dsub (dzero, done), dminus_one);
-  deq (__aeabi_dsub (dminus_two, dtwo), dminus_four);
-
-  /* Table 3.  Double-precision floating-point comparisons.  */
-  ieq (__aeabi_dcmpeq (done, done), 1);
-  ieq (__aeabi_dcmpeq (done, dzero), 0);
-  ieq (__aeabi_dcmpeq (dNaN, dzero), 0);
-  ieq (__aeabi_dcmpeq (dNaN, dNaN), 0);
-
-  ieq (__aeabi_dcmplt (dzero, done), 1);
-  ieq (__aeabi_dcmplt (done, dzero), 0);
-  ieq (__aeabi_dcmplt (dzero, dzero), 0);
-  ieq (__aeabi_dcmplt (dzero, dNaN), 0);
-  ieq (__aeabi_dcmplt (dNaN, dNaN), 0);
-
-  ieq (__aeabi_dcmple (dzero, done), 1);
-  ieq (__aeabi_dcmple (done, dzero), 0);
-  ieq (__aeabi_dcmple (dzero, dzero), 1);
-  ieq (__aeabi_dcmple (dzero, dNaN), 0);
-  ieq (__aeabi_dcmple (dNaN, dNaN), 0);
-
-  ieq (__aeabi_dcmpge (dzero, done), 0);
-  ieq (__aeabi_dcmpge (done, dzero), 1);
-  ieq (__aeabi_dcmpge (dzero, dzero), 1);
-  ieq (__aeabi_dcmpge (dzero, dNaN), 0);
-  ieq (__aeabi_dcmpge (dNaN, dNaN), 0);
-
-  ieq (__aeabi_dcmpgt (dzero, done), 0);
-  ieq (__aeabi_dcmpgt (done, dzero), 1);
-  ieq (__aeabi_dcmplt (dzero, dzero), 0);
-  ieq (__aeabi_dcmpgt (dzero, dNaN), 0);
-  ieq (__aeabi_dcmpgt (dNaN, dNaN), 0);
-
-  ieq (__aeabi_dcmpun (done, done), 0);
-  ieq (__aeabi_dcmpun (done, dzero), 0);
-  ieq (__aeabi_dcmpun (dNaN, dzero), 1);
-  ieq (__aeabi_dcmpun (dNaN, dNaN), 1);
-
-  /* Table 4.  Single-precision floating-point arithmetic.  */
-  feq (__aeabi_fadd (fzero, fone), fone);
-  feq (__aeabi_fadd (fone, fone), ftwo);
-  feq (__aeabi_fdiv (fminus_four, fminus_two), ftwo);
-  feq (__aeabi_fdiv (fminus_two, ftwo), fminus_one);
-  feq (__aeabi_fmul (ftwo, ftwo), ffour);
-  feq (__aeabi_fmul (fminus_one, fminus_two), ftwo);
-  feq (__aeabi_fneg (fminus_one), fone);
-  feq (__aeabi_fneg (ffour), fminus_four);
-  feq (__aeabi_frsub (fone, fzero), fminus_one);
-  feq (__aeabi_frsub (ftwo, fminus_two), fminus_four);
-  feq (__aeabi_fsub (fzero, fone), fminus_one);
-  feq (__aeabi_fsub (fminus_two, ftwo), fminus_four);
-
-  /* Table 5.  Single-precision floating-point comparisons.  */
-  ieq (__aeabi_fcmpeq (fone, fone), 1);
-  ieq (__aeabi_fcmpeq (fone, fzero), 0);
-  ieq (__aeabi_fcmpeq (fNaN, fzero), 0);
-  ieq (__aeabi_fcmpeq (fNaN, fNaN), 0);
-
-  ieq (__aeabi_fcmplt (fzero, fone), 1);
-  ieq (__aeabi_fcmplt (fone, fzero), 0);
-  ieq (__aeabi_fcmplt (fzero, fzero), 0);
-  ieq (__aeabi_fcmplt (fzero, fNaN), 0);
-  ieq (__aeabi_fcmplt (fNaN, fNaN), 0);
-
-  ieq (__aeabi_fcmple (fzero, fone), 1);
-  ieq (__aeabi_fcmple (fone, fzero), 0);
-  ieq (__aeabi_fcmple (fzero, fzero), 1);
-  ieq (__aeabi_fcmple (fzero, fNaN), 0);
-  ieq (__aeabi_fcmple (fNaN, fNaN), 0);
-
-  ieq (__aeabi_fcmpge (fzero, fone), 0);
-  ieq (__aeabi_fcmpge (fone, fzero), 1);
-  ieq (__aeabi_fcmpge (fzero, fzero), 1);
-  ieq (__aeabi_fcmpge (fzero, fNaN), 0);
-  ieq (__aeabi_fcmpge (fNaN, fNaN), 0);
-
-  ieq (__aeabi_fcmpgt (fzero, fone), 0);
-  ieq (__aeabi_fcmpgt (fone, fzero), 1);
-  ieq (__aeabi_fcmplt (fzero, fzero), 0);
-  ieq (__aeabi_fcmpgt (fzero, fNaN), 0);
-  ieq (__aeabi_fcmpgt (fNaN, fNaN), 0);
-
-  ieq (__aeabi_fcmpun (fone, fone), 0);
-  ieq (__aeabi_fcmpun (fone, fzero), 0);
-  ieq (__aeabi_fcmpun (fNaN, fzero), 1);
-  ieq (__aeabi_fcmpun (fNaN, fNaN), 1);
-
-  /* Table 6.  Floating-point to integer conversions.  */
-  ieq (__aeabi_d2iz (dminus_one), -1);
-  ueq (__aeabi_d2uiz (done), 1);
-  leq (__aeabi_d2lz (dminus_two), -2LL);
-  uleq (__aeabi_d2ulz (dfour), 4LL);
-  ieq (__aeabi_f2iz (fminus_one), -1);
-  ueq (__aeabi_f2uiz (fone), 1);
-  leq (__aeabi_f2lz (fminus_two), -2LL);
-  uleq (__aeabi_f2ulz (ffour), 4LL);
-
-  /* Table 7.  Conversions between floating types.  */
-  feq (__aeabi_d2f (dtwo), ftwo);
-  deq (__aeabi_f2d (fminus_four), dminus_four);
-
-  /* Table 8.  Integer to floating-point conversions.  */
-  deq (__aeabi_i2d (-1), dminus_one);
-  deq (__aeabi_ui2d (2), dtwo);
-  deq (__aeabi_l2d (-1), dminus_one);
-  deq (__aeabi_ul2d (2ULL), dtwo);
-  feq (__aeabi_i2f (-1), fminus_one);
-  feq (__aeabi_ui2f (2), ftwo);
-  feq (__aeabi_l2f (-1), fminus_one);
-  feq (__aeabi_ul2f (2ULL), ftwo);
-
-  /* Table 9.  Long long functions.  */
-  leq (__aeabi_lmul (4LL, -1LL), -4LL);
-  leq (__aeabi_llsl (2LL, 1), 4LL);
-  leq (__aeabi_llsr (-1LL, 63), 1);
-  leq (__aeabi_lasr (-1LL, 63), -1);
-
-  result = lcmp_results;
-  for (i = 0; i < NUM_CMP_VALUES; i++)
-    for (j = 0; j < NUM_CMP_VALUES; j++)
-      for (k = 0; k < NUM_CMP_VALUES; k++)
-	for (n = 0; n < NUM_CMP_VALUES; n++)
-	  {
-	    ieq (signof (__aeabi_lcmp
-			  (((long long)cmp_val[i] << 32) | cmp_val[k],
-			   ((long long)cmp_val[j] << 32) | cmp_val[n])),
-			   *result);
-	    result++;
-	  }
-  result = ulcmp_results;
-  for (i = 0; i < NUM_CMP_VALUES; i++)
-    for (j = 0; j < NUM_CMP_VALUES; j++)
-      for (k = 0; k < NUM_CMP_VALUES; k++)
-	for (n = 0; n < NUM_CMP_VALUES; n++)
-	  {
-	    ieq (signof (__aeabi_ulcmp
-			  (((long long)cmp_val[i] << 32) | cmp_val[k],
-			   ((long long)cmp_val[j] << 32) | cmp_val[n])),
-			   *result);
-	    result++;
-	  }
-
-  ieq (__aeabi_idiv (-550, 11), -50);
-  ueq (__aeabi_uidiv (4000000000U, 1000000U), 4000U);
-
-  for (i = 0; i < 256; i++)
-    bytes[i] = i;
-
-#ifdef __ARMEB__
-  ieq (__aeabi_uread4 (bytes + 1), 0x01020304U);
-  leq (__aeabi_uread8 (bytes + 3), 0x030405060708090aLL);
-  ieq (__aeabi_uwrite4 (0x66778899U, bytes + 5), 0x66778899U);
-  leq (__aeabi_uwrite8 (0x2030405060708090LL, bytes + 15),
-       0x2030405060708090LL);
-#else
-  ieq (__aeabi_uread4 (bytes + 1), 0x04030201U);
-  leq (__aeabi_uread8 (bytes + 3), 0x0a09080706050403LL);
-  ieq (__aeabi_uwrite4 (0x99887766U, bytes + 5), 0x99887766U);
-  leq (__aeabi_uwrite8 (0x9080706050403020LL, bytes + 15),
-       0x9080706050403020LL);
-#endif
-
-  for (i = 0; i < 4; i++)
-    ieq (bytes[5 + i], (6 + i) * 0x11);
-
-  for (i = 0; i < 8; i++)
-    ieq (bytes[15 + i], (2 + i) * 0x10);
-
-  exit (0);		
-}
Index: gcc/testsuite/g++.dg/pph/c2pr36533.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/c2pr36533.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c2pr36533.cc	(working copy)
@@ -1,2 +0,0 @@
-/* { dg-options "-w -fpermissive" } */
-#include "c1pr36533.h"
Index: gcc/testsuite/g++.dg/pph/c1pr36533.h
===================================================================
--- gcc/testsuite/g++.dg/pph/c1pr36533.h	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/c1pr36533.h	(working copy)
@@ -1,16 +0,0 @@
-/* PR target/36533 */
-/* { dg-options "-w -fpermissive" } */
-
-#ifndef C1PR36533_H
-#define C1PR36533_H
-
-#include <string.h>
-#include <sys/mman.h>
-
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#include "a0pr36533.h"
-
-#endif
Index: gcc/testsuite/g++.dg/pph/x1dynarray1.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/x1dynarray1.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/x1dynarray1.cc	(working copy)
@@ -1,4 +1,4 @@
-// { dg-do run }
+// { dg-do link }
 // { dg-xfail-if "BOGUS" { "*-*-*" } { "-fpph-map=pph.map" } }
 
 #include "x0dynarray1.h"
Index: gcc/testsuite/g++.dg/pph/x1dynarray2b.cc
===================================================================
--- gcc/testsuite/g++.dg/pph/x1dynarray2b.cc	(revision 176223)
+++ gcc/testsuite/g++.dg/pph/x1dynarray2b.cc	(working copy)
@@ -1,4 +1,5 @@
-// { dg-do run }
+// { dg-xfail-if "BOGUS" { "*-*-*" } { "-fpph-map=pph.map" } }
+// { dg-do link }
 
 #include "x0dynarray2.h"
 
