In gcc/:

	* config/rs6000/sysv4.h (SUBTARGET_OVERRIDE_OPTIONS): Handle
	-mcall-i960.
	(ASM_SPEC): Likewise.
	(CC1_ENDIAN_LITTLE_SPEC): Likewise.
	(CC1_SPEC): Likewise.
	(LINK_TARGET_SPEC): Likewise.
	(CPP_ENDIAN_SPEC): Likewise.

	* Makefile.in (check-consistency): New target.

In gcc/testsuite/:
	* consistency.vlad: New directory, 1665 files.

From-SVN: r39609

gcc/ChangeLog

+2001-02-12  Geoffrey Keating  <geoffk@redhat.com>
+
+	* config/rs6000/sysv4.h (SUBTARGET_OVERRIDE_OPTIONS): Handle
+	-mcall-i960.
+	(ASM_SPEC): Likewise.
+	(CC1_ENDIAN_LITTLE_SPEC): Likewise.
+	(CC1_SPEC): Likewise.
+	(LINK_TARGET_SPEC): Likewise.
+	(CPP_ENDIAN_SPEC): Likewise.
+	* Makefile.in (check-consistency): New target.
+
 2001-02-12  Joseph S. Myers  <jsm28@cam.ac.uk>
 
 	* c-decl.c (grokdeclarator): In C99 mode, give the more specific

gcc/Makefile.in

@@ -2842,6 +2842,16 @@ check-po:
 	   $(MAKE) -C po check-po; \
 	fi
 
+check-consistency: testsuite/site.exp
+	-rootme=`pwd`; export rootme; \
+	srcdir=`cd ${srcdir}; pwd` ; export srcdir ; \
+	cd testsuite; \
+	EXPECT=${EXPECT} ; export EXPECT ; \
+	if [ -f $${rootme}/../expect/expect ] ; then  \
+	   TCL_LIBRARY=`cd .. ; cd ${srcdir}/../tcl/library ; pwd` ; \
+	   export TCL_LIBRARY ; fi ; \
+	$(RUNTEST) --tool consistency $(RUNTESTFLAGS)
+
 # These exist for maintenance purposes.
 
 # Update the tags table.

gcc/config/rs6000/sysv4.h

@@ -199,6 +199,13 @@ do {									\
     rs6000_current_abi = ABI_V4;					\
   else if (!strcmp (rs6000_abi_name, "solaris"))			\
     rs6000_current_abi = ABI_SOLARIS;					\
+  else if (!strcmp (rs6000_abi_name, "i960-old"))			\
+    {									\
+      rs6000_current_abi = ABI_V4;					\
+      target_flags |= (MASK_LITTLE_ENDIAN | MASK_EABI			\
+		       | MASK_NO_BITFIELD_WORD);			\
+      target_flags &= ~MASK_STRICT_ALIGN;				\
+    }									\
   else									\
     {									\
       rs6000_current_abi = ABI_V4;					\
@@ -1061,13 +1068,16 @@ do {									\
 %{mlittle} %{mlittle-endian} %{mbig} %{mbig-endian} \
 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
     %{mcall-solaris: -mlittle -msolaris} \
+    %{mcall-i960-old: -mlittle} \
     %{mcall-linux: -mbig} }}}}"
 
 #define	CC1_ENDIAN_BIG_SPEC ""
 
 #define	CC1_ENDIAN_LITTLE_SPEC "\
 %{!mstrict-align: %{!mno-strict-align: \
+    %{!mcall-i960-old: \
 	-mstrict-align \
+    } \
 }}"
 
 #define	CC1_ENDIAN_DEFAULT_SPEC "%(cc1_endian_big_spec)"
@@ -1079,10 +1089,11 @@ do {									\
 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
     %{mcall-aixdesc: -mbig %(cc1_endian_big) } \
     %{mcall-solaris: -mlittle %(cc1_endian_little) } \
+    %{mcall-i960-old: -mlittle %(cc1_endian_little) } \
     %{mcall-linux: -mbig %(cc1_endian_big) } \
-    %{!mcall-aixdesc: %{!mcall-solaris: %{!mcall-linux: \
+    %{!mcall-aixdesc: %{!mcall-solaris: %{!mcall-i960-old: %{!mcall-linux: \
 	    %(cc1_endian_default) \
-    }}} \
+    }}}} \
 }}}} \
 %{mcall-solaris: -mregnames } \
 %{mno-sdata: -msdata=none } \
@@ -1090,6 +1101,7 @@ do {									\
 %{!meabi: %{!mno-eabi: \
     %{mrelocatable: -meabi } \
     %{mcall-solaris: -mno-eabi } \
+    %{mcall-i960-old: -meabi } \
     %{mcall-linux: -mno-eabi }}} \
 %{msdata: -msdata=default} \
 %{mno-sdata: -msdata=none} \
@@ -1163,6 +1175,7 @@ do {									\
 #define	LINK_TARGET_SPEC "\
 %{mlittle: --oformat elf32-powerpcle } %{mlittle-endian: --oformat elf32-powerpcle } \
 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
+    %{mcall-i960-old: --oformat elf32-powerpcle} \
     %{mcall-solaris: --oformat elf32-powerpcle} \
   }}}}"
 
@@ -1221,6 +1234,7 @@ do {									\
 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
     %{mcall-solaris: %(cpp_endian_solaris) } \
     %{mcall-linux: %(cpp_endian_big) } \
+    %{mcall-i960-old: %(cpp_endian_little) } \
     %{mcall-aixdesc:  %(cpp_endian_big) } \
     %{!mcall-solaris: %{!mcall-linux: %{!mcall-aixdesc: %(cpp_endian_default) }}}}}}}"
 

gcc/testsuite/ChangeLog

+2001-02-12  Geoffrey Keating  <geoffk@redhat.com>
+
+	* consistency.vlad: New directory, 1665 files.
+
 2001-02-12  Joseph S. Myers  <jsm28@cam.ac.uk>
 
 	* gcc.dg/c99-impl-int-1.c: Use stricter error string for implicit

gcc/testsuite/consistency.vlad/README

+  This directory contains tests and scripts for consistency checking
+compilers.  They could be used for consistency checking different
+C/C++ compiler for one platform or C/C++ compilers for different
+platforms.
+
+  For example, to check the consistency, you could type
+
+   make check-consistency RUNTESTFLAGS='BASE_COMPILER=i960-97r2 CONSISTENCY_OPTIONS="-O2 -fvtable-thunks -mno-strict-align -fno-rtti -fcheck-new -mcall-i960-old -mlittle-endian" NO_LONG_DOUBLE=1 NO_LIBGLOSS_LIBRARY_OPTIONS=1'
+
+  In this example, DEJAGNU driver vlad.exp will process all C/C++
+tests in all subdirectories (e.g. layout) started with lower case
+letter.  C tests (with suffixes .c) will be compiled by C compiler
+only.  C++ tests will be compiled by C and C++ compilers.  It is
+supposed that each test outputs the result which is saved in temp_dir
+as
+   <basename of the test>.out
+or
+   <basename of the test>.out++
+
+correspondingly for C compiler and C++ compiler.  For example, there
+will be two output files
+
+   `align-double.out' and `align-double.out++'
+
+for test `align-double.c'.
+
+  After this if there is subdirectory <BASE_COMPILER>-results
+(`i960-97r2-results' in our example) and there is corresponding saved
+output file for the base compiler the the files are compared in order
+to check consistency.
+
+  To create the base for future comparisons of output files, you
+should create the directory and move output files from the temporary
+directory into the created directory.
+
+The test script file has the following parameters
+
+ 1. BASE_COMPILER.  The variable must be defined for work the script
+    properly.
+
+ 2. CONSISTENCY_OPTIONS.  The options which will be used for
+    compilations.  The default value is "-O2".
+
+ 3. NO_LONG_DOUBLE.  If the variable value is not zero, the tests
+    which contain long double are expected to be fail.
+
+ 4. NO_LIBGLOSS_LIBRARY_OPTIONS.  If the variable value is not zero,
+    the tests are compiled without standard dejagnu libgloss library
+    paths.
+
+  Currently, there is directory `layout' for checking allocation
+parameters of C/C++ compiler and subdirectory i960-97r2 which contains
+the test results for 97r2 i960-vxworks C/C++ compiler.
+
+  You can create other consistency tests.  Simply, create a directory
+started with lower case letter, place the tests and create the
+subdirectory with the test results for a base compiler.  If you need
+to compile tests in a directory with a wrap file simply place the file
+name (e.g. _dummy_stab.S) in file WRAP_FILE in the test directory.
+
+  The tests will be only compiled (and the test results will not be
+compared) if you place <basename of the test>.conly in the directory
+of the test.  You can use own driver for checking consistency.  To
+make this, place the TCL script with name <basename of the test>.cexp.
+
+Vladimir Makarov <vmakarov@cygnus.com>

gcc/testsuite/consistency.vlad/layout/a-char.c

+#include <stdio.h>
+
+static char a [10];
+static char e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array char:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-double.c

+#include <stdio.h>
+
+static double a [10];
+static double e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array double:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-float.c

+#include <stdio.h>
+
+static float a [10];
+static float e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array float:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-int.c

+#include <stdio.h>
+
+static int a [10];
+static int e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array int:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-long.c

+#include <stdio.h>
+
+static long a [10];
+static long e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array long:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-longdouble.c

+#include <stdio.h>
+
+static long double a [10];
+static long double e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array longdouble:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-longlong.c

+#include <stdio.h>
+
+static long long a [10];
+static long long e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array longlong:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-char.c

+#include <stdio.h>
+
+static struct sss{
+  char f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with char:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-double.c

+#include <stdio.h>
+
+static struct sss{
+  double f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with double:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-float.c

+#include <stdio.h>
+
+static struct sss{
+  float f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with float:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-int.c

+#include <stdio.h>
+
+static struct sss{
+  int f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with int:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-long.c

+#include <stdio.h>
+
+static struct sss{
+  long f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with long:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-longdouble.c

+#include <stdio.h>
+
+static struct sss{
+  long double f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with longdouble:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-longlong.c

+#include <stdio.h>
+
+static struct sss{
+  long long f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with longlong:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-pointer.c

+#include <stdio.h>
+
+static struct sss{
+  char * f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with pointer:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-ptrdiff_t.c

+#include <stdio.h>
+#include <stddef.h>
+
+static struct sss{
+  ptrdiff_t f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with ptrdiff_t:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-of-s-short.c

+#include <stdio.h>
+
+static struct sss{
+  short f;
+} a[10];
+
+int main (void) {
+  printf ("++++Array of struct with short:\n");
+  printf ("size=%d,align=%d,displ-a[5]=%d,align-a[5]=%d\n",
+          sizeof (a), __alignof__ (a), (char*)&a[5] - (char*)a, __alignof__ (a[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-pointer.c

+#include <stdio.h>
+
+static char * a [10];
+static char * e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array pointer:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-ptrdiff_t.c

+#include <stdio.h>
+#include <stddef.h>
+
+static ptrdiff_t a [10];
+static ptrdiff_t e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array ptrdiff_t:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-short.c

+#include <stdio.h>
+
+static short a [10];
+static short e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array short:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-size_t.c

+#include <stdio.h>
+#include <stddef.h>
+
+static size_t a [10];
+static size_t e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array size_t:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/a-wchar_t.c

+#include <stdio.h>
+#include <stddef.h>
+
+static wchar_t a [10];
+static wchar_t e [0]; /* GCC only */
+
+int main (void) {
+  printf ("+++Array wchar_t:\n");
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (a), __alignof__ (a),
+          (char *) &a[5] - (char *) a, __alignof__ (a[5]));
+  printf ("size=%d,align=%d,5th-elem-offset=%d,5th-elem-align=%d\n",
+          sizeof (e), __alignof__ (e),
+          (char *) &e[5] - (char *) a, __alignof__ (e[5]));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-bool.cpp

+#include <stdio.h>
+
+static bool bbb;
+
+int main(void)
+{
+  printf ("+++Bool alignment:\n");
+  printf ("%d\n", __alignof__ (bbb));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-char.c

+#include <stdio.h>
+
+static char ccc;
+
+int main(void)
+{
+  printf ("+++Char alignment:\n");
+  printf ("%d\n", __alignof__ (ccc));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-double.c

+#include <stdio.h>
+
+static double d;
+
+int main(void)
+{
+  printf ("+++Double alignment:\n");
+  printf ("%d\n", __alignof__ (d));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-float.c

+#include <stdio.h>
+
+static float f;
+
+int main(void)
+{
+  printf ("+++Float alignment:\n");
+  printf ("%d\n", __alignof__ (f));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-int.c

+#include <stdio.h>
+
+static int i;
+
+int main(void)
+{
+  printf ("+++Int alignment:\n");
+  printf ("%d\n", __alignof__ (i));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-long.c

+#include <stdio.h>
+
+static long lll;
+
+int main(void)
+{
+  printf ("+++Long alignment:\n");
+  printf ("%d\n", __alignof__ (lll));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-longdouble.c

+#include <stdio.h>
+
+static long double ld;
+
+int main(void)
+{
+  printf ("+++Long Double alignment:\n");
+  printf ("%d\n", __alignof__ (ld));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-longlong.c

+#include <stdio.h>
+
+static long long ll;
+
+int main(void)
+{
+  printf ("+++Long long alignment:\n");
+  printf ("%d\n", __alignof__ (ll));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-pointer.c

+#include <stdio.h>
+
+static char *p;
+
+int main(void)
+{
+  printf ("+++Pointer alignment:\n");
+  printf ("%d\n", __alignof__ (p));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-ptrdiff.c

+#include <stdio.h>
+#include <stddef.h>
+
+static ptrdiff_t pd;
+
+int main(void)
+{
+  printf ("+++ptrdiff_t alignment:\n");
+  printf ("%d\n", __alignof__ (pd));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-short.c

+#include <stdio.h>
+
+static short sss;
+
+int main(void)
+{
+  printf ("+++Short alignment:\n");
+  printf ("%d\n", __alignof__ (sss));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-size.c

+#include <stdio.h>
+#include <stddef.h>
+
+static size_t sss;
+
+int main(void)
+{
+  printf ("+++size_t alignment:\n");
+  printf ("%d\n", __alignof__ (sss));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/align-wchar.c

+#include <stdio.h>
+#include <stddef.h>
+
+static wchar_t w;
+
+int main(void)
+{
+  printf ("+++wchar_t alignment:\n");
+  printf ("%d\n", __alignof__ (w));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/biggest-field-align.c

+#include <stdio.h>
+#include <stddef.h>
+
+static struct {char m;} s0;
+static struct {short m;} s1;
+static struct {int m;} s2;
+static struct {long m;} s3;
+static struct {long long m;} s4;
+static struct {char * m;} s5;
+static struct {float m;} s6;
+static struct {double m;} s7;
+static struct {long double m;} s8;
+static struct {ptrdiff_t m;} s9;
+static struct {size_t m;} s10;
+static struct {wchar_t m;} s11;
+static struct {struct {char m;}m;} s12;
+static struct {struct {short m;}m;} s13;
+static struct {struct {int m;}m;} s14;
+static struct {struct {long m;}m;} s15;
+static struct {struct {long long m;}m;} s16;
+static struct {struct {char * m;}m;} s17;
+static struct {struct {float m;}m;} s18;
+static struct {struct {double m;}m;} s19;
+static struct {struct {long double m;}m;} s20;
+static struct {struct {ptrdiff_t m;}m;} s21;
+static struct {struct {size_t m;}m;} s22;
+static struct {struct {wchar_t m;}m;} s23;
+static struct {char m [10];} s24;
+static struct {short m [10];} s25;
+static struct {int m [10];} s26;
+static struct {long m [10];} s27;
+static struct {long long m [10];} s28;
+static struct {char * m [10];} s29;
+static struct {float m [10];} s30;
+static struct {double m [10];} s31;
+static struct {long double m [10];} s32;
+static struct {ptrdiff_t m [10];} s33;
+static struct {size_t m [10];} s34;
+static struct {wchar_t m [10];} s35;
+static struct {int :0; char m;} s36;
+static struct {int :0; short m;} s37;
+static struct {int :0; int m;} s38;
+static struct {int :0; long m;} s39;
+static struct {int :0; long long m;} s40;
+static struct {int :0; char * m;} s41;
+static struct {int :0; float m;} s42;
+static struct {int :0; double m;} s43;
+static struct {int :0; long double m;} s44;
+static struct {int :0; ptrdiff_t m;} s45;
+static struct {int :0; size_t m;} s46;
+static struct {int :0; wchar_t m;} s47;
+int main (void) {
+  int max_align = 0;
+  printf ("+++Biggest field alignment:\n");
+  if (max_align < __alignof__ (s0.m))
+     max_align = __alignof__ (s0.m);
+  if (max_align < __alignof__ (s1.m))
+     max_align = __alignof__ (s1.m);
+  if (max_align < __alignof__ (s2.m))
+     max_align = __alignof__ (s2.m);
+  if (max_align < __alignof__ (s3.m))
+     max_align = __alignof__ (s3.m);
+  if (max_align < __alignof__ (s4.m))
+     max_align = __alignof__ (s4.m);
+  if (max_align < __alignof__ (s5.m))
+     max_align = __alignof__ (s5.m);
+  if (max_align < __alignof__ (s6.m))
+     max_align = __alignof__ (s6.m);
+  if (max_align < __alignof__ (s7.m))
+     max_align = __alignof__ (s7.m);
+  if (max_align < __alignof__ (s8.m))
+     max_align = __alignof__ (s8.m);
+  if (max_align < __alignof__ (s9.m))
+     max_align = __alignof__ (s9.m);
+  if (max_align < __alignof__ (s10.m))
+     max_align = __alignof__ (s10.m);
+  if (max_align < __alignof__ (s11.m))
+     max_align = __alignof__ (s11.m);
+  if (max_align < __alignof__ (s12.m))
+     max_align = __alignof__ (s12.m);
+  if (max_align < __alignof__ (s13.m))
+     max_align = __alignof__ (s13.m);
+  if (max_align < __alignof__ (s14.m))
+     max_align = __alignof__ (s14.m);
+  if (max_align < __alignof__ (s15.m))
+     max_align = __alignof__ (s15.m);
+  if (max_align < __alignof__ (s16.m))
+     max_align = __alignof__ (s16.m);
+  if (max_align < __alignof__ (s17.m))
+     max_align = __alignof__ (s17.m);
+  if (max_align < __alignof__ (s18.m))
+     max_align = __alignof__ (s18.m);
+  if (max_align < __alignof__ (s19.m))
+     max_align = __alignof__ (s19.m);
+  if (max_align < __alignof__ (s20.m))
+     max_align = __alignof__ (s20.m);
+  if (max_align < __alignof__ (s21.m))
+     max_align = __alignof__ (s21.m);
+  if (max_align < __alignof__ (s22.m))
+     max_align = __alignof__ (s22.m);
+  if (max_align < __alignof__ (s23.m))
+     max_align = __alignof__ (s23.m);
+  if (max_align < __alignof__ (s24.m))
+     max_align = __alignof__ (s24.m);
+  if (max_align < __alignof__ (s25.m))
+     max_align = __alignof__ (s25.m);
+  if (max_align < __alignof__ (s26.m))
+     max_align = __alignof__ (s26.m);
+  if (max_align < __alignof__ (s27.m))
+     max_align = __alignof__ (s27.m);
+  if (max_align < __alignof__ (s28.m))
+     max_align = __alignof__ (s28.m);
+  if (max_align < __alignof__ (s29.m))
+     max_align = __alignof__ (s29.m);
+  if (max_align < __alignof__ (s30.m))
+     max_align = __alignof__ (s30.m);
+  if (max_align < __alignof__ (s31.m))
+     max_align = __alignof__ (s31.m);
+  if (max_align < __alignof__ (s32.m))
+     max_align = __alignof__ (s32.m);
+  if (max_align < __alignof__ (s33.m))
+     max_align = __alignof__ (s33.m);
+  if (max_align < __alignof__ (s34.m))
+     max_align = __alignof__ (s34.m);
+  if (max_align < __alignof__ (s35.m))
+     max_align = __alignof__ (s35.m);
+  if (max_align < __alignof__ (s36.m))
+     max_align = __alignof__ (s36.m);
+  if (max_align < __alignof__ (s37.m))
+     max_align = __alignof__ (s37.m);
+  if (max_align < __alignof__ (s38.m))
+     max_align = __alignof__ (s38.m);
+  if (max_align < __alignof__ (s39.m))
+     max_align = __alignof__ (s39.m);
+  if (max_align < __alignof__ (s40.m))
+     max_align = __alignof__ (s40.m);
+  if (max_align < __alignof__ (s41.m))
+     max_align = __alignof__ (s41.m);
+  if (max_align < __alignof__ (s42.m))
+     max_align = __alignof__ (s42.m);
+  if (max_align < __alignof__ (s43.m))
+     max_align = __alignof__ (s43.m);
+  if (max_align < __alignof__ (s44.m))
+     max_align = __alignof__ (s44.m);
+  if (max_align < __alignof__ (s45.m))
+     max_align = __alignof__ (s45.m);
+  if (max_align < __alignof__ (s46.m))
+     max_align = __alignof__ (s46.m);
+  if (max_align < __alignof__ (s47.m))
+     max_align = __alignof__ (s47.m);
+  printf ("max field align=%d\n", max_align);
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-char=%d,\nalign-char=%d,align-char=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-double=%d,\nalign-char=%d,align-double=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-float=%d,\nalign-char=%d,align-float=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  int m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with int inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-int=%d,\nalign-char=%d,align-int=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with long inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-long=%d,\nalign-char=%d,align-long=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-longdouble.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  long double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with longdouble inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-longdouble=%d,\nalign-char=%d,align-longdouble=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-longlong.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  long long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with longlong inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-longlong=%d,\nalign-char=%d,align-longlong=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-pointer.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  char * m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with pointer inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-pointer=%d,\nalign-char=%d,align-pointer=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-1-c-short.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+
+static class sss: public c{
+public:
+  short m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with short inhereting class with char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-char=%d,offset-short=%d,\nalign-char=%d,align-short=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  char f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  double f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  float f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  int f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  long f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & long:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-longdouble.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  long double f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & longdouble:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-longlong.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  long long f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & longlong:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-pointer.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  char * f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & pointer:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-char-2-c-short.cpp

+#include <stdio.h>
+
+class c{
+public:
+  char f;
+};
+
+class c2{
+public:
+  short f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting classes with char & short:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-char=%d,\nalign-double=%d,align-char=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-double=%d,\nalign-double=%d,align-double=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-float=%d,\nalign-double=%d,align-float=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  int m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with int inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-int=%d,\nalign-double=%d,align-int=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with long inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-long=%d,\nalign-double=%d,align-long=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-longdouble.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  long double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with longdouble inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-longdouble=%d,\nalign-double=%d,align-longdouble=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-longlong.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  long long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with longlong inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-longlong=%d,\nalign-double=%d,align-longlong=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-pointer.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  char * m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with pointer inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-pointer=%d,\nalign-double=%d,align-pointer=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-1-c-short.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+
+static class sss: public c{
+public:
+  short m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with short inhereting class with double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-double=%d,offset-short=%d,\nalign-double=%d,align-short=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  char f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  double f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  float f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  int f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  long f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & long:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-longdouble.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  long double f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & longdouble:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-longlong.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  long long f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & longlong:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-pointer.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  char * f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & pointer:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-double-2-c-short.cpp

+#include <stdio.h>
+
+class c{
+public:
+  double f;
+};
+
+class c2{
+public:
+  short f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting classes with double & short:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-char=%d,\nalign-float=%d,align-char=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-double=%d,\nalign-float=%d,align-double=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-float=%d,\nalign-float=%d,align-float=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  int m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with int inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-int=%d,\nalign-float=%d,align-int=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with long inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-long=%d,\nalign-float=%d,align-long=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-longdouble.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  long double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with longdouble inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-longdouble=%d,\nalign-float=%d,align-longdouble=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-longlong.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  long long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with longlong inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-longlong=%d,\nalign-float=%d,align-longlong=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-pointer.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  char * m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with pointer inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-pointer=%d,\nalign-float=%d,align-pointer=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-1-c-short.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+
+static class sss: public c{
+public:
+  short m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with short inhereting class with float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-float=%d,offset-short=%d,\nalign-float=%d,align-short=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  char f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & char:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  double f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & double:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  float f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & float:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  int f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}
+

gcc/testsuite/consistency.vlad/layout/c-float-2-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  long f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & long:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-longdouble.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  long double f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & longdouble:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-longlong.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  long long f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & longlong:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-pointer.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  char * f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & pointer:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-float-2-c-short.cpp

+#include <stdio.h>
+
+class c{
+public:
+  float f;
+};
+
+class c2{
+public:
+  short f2;
+};
+
+
+static class sss: public c, public c2{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting classes with float & short:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-f=%d,offset-f2=%d,offset-m=%d,\nalign-f=%d,align-f2=%d,align-m=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, f2), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.f2), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-int-1-c-char.cpp

+#include <stdio.h>
+
+class c{
+public:
+  int f;
+};
+
+
+static class sss: public c{
+public:
+  char m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with char inhereting class with int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-int=%d,offset-char=%d,\nalign-int=%d,align-char=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-int-1-c-double.cpp

+#include <stdio.h>
+
+class c{
+public:
+  int f;
+};
+
+
+static class sss: public c{
+public:
+  double m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with double inhereting class with int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-int=%d,offset-double=%d,\nalign-int=%d,align-double=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-int-1-c-float.cpp

+#include <stdio.h>
+
+class c{
+public:
+  int f;
+};
+
+
+static class sss: public c{
+public:
+  float m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with float inhereting class with int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-int=%d,offset-float=%d,\nalign-int=%d,align-float=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-int-1-c-int.cpp

+#include <stdio.h>
+
+class c{
+public:
+  int f;
+};
+
+
+static class sss: public c{
+public:
+  int m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with int inhereting class with int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-int=%d,offset-int=%d,\nalign-int=%d,align-int=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}

gcc/testsuite/consistency.vlad/layout/c-int-1-c-long.cpp

+#include <stdio.h>
+
+class c{
+public:
+  int f;
+};
+
+
+static class sss: public c{
+public:
+  long m;
+} sss;
+
+#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
+
+int main (void) {
+  printf ("++Class with long inhereting class with int:\n");
+  printf ("size=%d,align=%d\n", sizeof (sss), __alignof__ (sss));
+  printf ("offset-int=%d,offset-long=%d,\nalign-int=%d,align-long=%d\n",
+          _offsetof (class sss, f), _offsetof (class sss, m),
+          __alignof__ (sss.f), __alignof__ (sss.m));
+  return 0;
+}