X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/027323f2d112002993c045865fed6e6501e46b9e..d85949accc8820a54c468fbdf930063be5873296:/acmacro/gras_arch.m4 diff --git a/acmacro/gras_arch.m4 b/acmacro/gras_arch.m4 index 8e7616878b..9ffccffa6a 100644 --- a/acmacro/gras_arch.m4 +++ b/acmacro/gras_arch.m4 @@ -1,4 +1,3 @@ -# BEGIN OF GRAS ARCH CHECK dnl dnl GRAS_DO_CHECK_SIZEOF: Get the size of a datatype (even in cross-compile) dnl 1: type tested @@ -6,6 +5,15 @@ dnl 2: extra include lines dnl 3: extra sizes to test dnl ("adapted" from openldap) dnl + +dnl Copyright (C) 2004, 2005, 2006, 2007. Martin Quinson. All rights reserved. + +dnl This file is part of the SimGrid project. This is free software: +dnl You can redistribute and/or modify it under the terms of the +dnl GNU LGPL (v2.1) licence. + + +# BEGIN OF GRAS ARCH CHECK AC_DEFUN([GRAS_DO_CHECK_SIZEOF], [changequote(<<, >>)dnl dnl The cache variable name (and of the result). @@ -13,10 +21,10 @@ AC_DEFUN([GRAS_DO_CHECK_SIZEOF], changequote([, ])dnl AC_CACHE_VAL(GRAS_CHECK_SIZEOF_RES, [for ac_size in 4 8 1 2 16 $3 ; do # List sizes in rough order of prevalence. - AC_TRY_COMPILE([#include "confdefs.h" + AC_COMPILE_IFELSE(AC_LANG_PROGRAM([#include "confdefs.h" #include $2 - ], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], GRAS_CHECK_SIZEOF_RES=$ac_size) + ], [switch (0) case 0: case (sizeof ($1) == $ac_size):;]), GRAS_CHECK_SIZEOF_RES=$ac_size) if test x$GRAS_CHECK_SIZEOF_RES != x ; then break; fi done ]) @@ -36,14 +44,35 @@ if test x$GRAS_CHECK_SIZEOF_RES = x ; then AC_MSG_ERROR([cannot determine a size for $1]) fi AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES) -changequote(<<, >>)dnl -dnl The name to #define. -define(<>, translit(sizeof_$1, [a-z *()], [A-Z_P__]))dnl -changequote([, ])dnl -AC_DEFINE_UNQUOTED(TYPE_NAME, $GRAS_CHECK_SIZEOF_RES, [The number of bytes in type $1]) -undefine([TYPE_NAME])dnl ]) +dnl +dnl GRAS_TWO_COMPLEMENT([type]): Make sure the type is two-complement +dnl warning, this does not work with char (quite logical) +dnl +AC_DEFUN([GRAS_TWO_COMPLEMENT], +[ +AC_MSG_CHECKING(whether $1 is two-complement) +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" +union { + signed $1 testInt; + unsigned char bytes[sizeof($1)]; +} intTester; +]],[[ + intTester.testInt = -2; + switch (0) { + case 0: + case (((unsigned int)intTester.bytes[0] + + (unsigned int)intTester.bytes[sizeof($1) - 1]) - 509) == 0: + } +]])], dnl end of AC LANG PROGRAM +[two_complement=yes],[two_complement=no] )dnl end of AC COMPILE IFELSE + +AC_MSG_RESULT($two_complement) +if test x$two_complement != xyes ; then + AC_MSG_ERROR([GRAS works only two-complement integers (yet)]) +fi +]) dnl dnl GRAS_SIGNED_SIZEOF: Get the size of the datatype, and make sure that @@ -76,86 +105,62 @@ if test x$unsigned != x$signed ; then fi AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES) -changequote(<<, >>)dnl -dnl The name to #define. -define(<>, translit(sizeof_$1, [a-z *()], [A-Z_P__]))dnl -changequote([, ])dnl -AC_DEFINE_UNQUOTED(TYPE_NAME, $GRAS_CHECK_SIZEOF_RES, [The number of bytes in type $1]) -undefine([TYPE_NAME])dnl ]) dnl dnl End of CHECK_SIGNED_SIZEOF dnl -dnl CHECK_IEEE_FP: determines if floating points are IEEE754 compliant -dnl (inspired from NWS code) -dnl -AC_DEFUN([CHECK_IEEE_FP], -[AC_MSG_CHECKING(if floating point datatypes are IEEE 754 compliant) -AC_TRY_COMPILE([#include "confdefs.h" -union { - double testFP; - unsigned char bytes[sizeof(double)]; -} doubleTester; -union { - float testFP; - unsigned char bytes[sizeof(float)]; -} floatTester; -],[ -if (sizeof(double) != 8 || sizeof(float) != 4) - return 1; - -memset(&doubleTester, 0, sizeof(doubleTester)); -memset(&floatTester, 0, sizeof(floatTester)); - -doubleTester.bytes[GRAS_BIGENDIAN ? sizeof(double) - 1 : 0]=192; -doubleTester.bytes[GRAS_BIGENDIAN ? sizeof(double) - 2 : 1] = - (sizeof(double) == 4) ? 128 : - (sizeof(double) == 8) ? 16 : - (sizeof(double) == 16) ? 1 : 0; -if (doubleTester.testFP != -4.0) return 1; - -floatTester.bytes[GRAS_BIGENDIAN ? sizeof(float) - 1 : 0]=192; -floatTester.bytes[GRAS_BIGENDIAN ? sizeof(float) - 2 : 1] = - (sizeof(float) == 4) ? 128 : - (sizeof(float) == 8) ? 16 : - (sizeof(float) == 16) ? 1 : 0; -if (floatTester.testFP != -4.0) return 1; - -return 0;],[IEEE_FP=yes -AC_DEFINE(IEEE_FP,1,[defines if this architecture floating point types are IEEE754 compliant]) -],[IEEE_FP=no - AC_MSG_ERROR([GRAS works only for little or big endian systems (yet)])])dnl end of AC_TRY_COMPILE -AC_MSG_RESULT($IEEE_FP) -])dnl end of CHECK_IEEE_FP - - - -dnl *************************8 -dnl +# GRAS_STRUCT_BOUNDARY(): Check the minimal alignment boundary of $1 in structures +# --------------------- +# (using integer, I hope no arch let it change with the content) +AC_DEFUN([GRAS_STRUCT_BOUNDARY], +[changequote(<<, >>)dnl + dnl The cache variable name (and of the result). + define(<>, translit(ac_cv_struct_boundary_$1, [ *()], [_pLR]))dnl + changequote([, ])dnl + AC_MSG_CHECKING(for the minimal structure boundary of $1) + + AC_CACHE_VAL(GRAS_STRUCT_BOUNDARY_RES, + [for ac_size in 1 2 4 8 16 32 64 3 ; do # List sizes in rough order of prevalence. + AC_COMPILE_IFELSE(AC_LANG_PROGRAM([#include "confdefs.h" + #include + struct s { char c; $1 i; }; + ],[switch (0) case 0: case (sizeof (struct s) == $ac_size+sizeof($1)):;]), GRAS_STRUCT_BOUNDARY_RES=$ac_size) + if test x$GRAS_STRUCT_BOUNDARY_RES != x ; then break; fi + done + ]) + AC_MSG_RESULT($GRAS_STRUCT_BOUNDARY_RES) + if test x$GRAS_STRUCT_BOUNDARY_RES = x ; then + AC_MSG_ERROR([Cannot determine the minimal alignment boundary of $1 in structures]) + fi +]) + +# GRAS_ARCH(): check the gras_architecture of this plateform +# ----------- +# The different cases here must be syncronized with the array in src/base/DataDesc/ddt_convert.c +# AC_DEFUN([GRAS_ARCH], [ # Check for the architecture AC_C_BIGENDIAN(endian=1,endian=0,AC_MSG_ERROR([GRAS works only for little or big endian systems (yet)])) +dnl Make sure we don't run on a non-two-complement arch, since we dunno convert them +dnl G RAS_TWO_COMPLEMENT(int) don't do this, it breaks cross-compile and all +dnl archs conform to this AC_DEFINE_UNQUOTED(GRAS_BIGENDIAN,$endian,[define if big endian]) -dnl FIXME: Use SIGNED instead of CHECK to make sure signed and unsigned type -dnl have same size -GRAS_CHECK_SIZEOF(char) -GRAS_CHECK_SIZEOF(short int) -GRAS_CHECK_SIZEOF(int) -GRAS_CHECK_SIZEOF(long int) -GRAS_CHECK_SIZEOF(long long int) - +GRAS_SIGNED_SIZEOF(char) GRAS_STRUCT_BOUNDARY(char) +GRAS_SIGNED_SIZEOF(short int) GRAS_STRUCT_BOUNDARY(short int) +GRAS_SIGNED_SIZEOF(int) GRAS_STRUCT_BOUNDARY(int) +GRAS_SIGNED_SIZEOF(long int) GRAS_STRUCT_BOUNDARY(long int) +GRAS_SIGNED_SIZEOF(long long int) GRAS_STRUCT_BOUNDARY(long long int) + +GRAS_STRUCT_BOUNDARY(float) GRAS_STRUCT_BOUNDARY(double) -GRAS_CHECK_SIZEOF(void *) -GRAS_CHECK_SIZEOF(void (*) (void)) +GRAS_CHECK_SIZEOF(void *) GRAS_STRUCT_BOUNDARY(void *) +GRAS_CHECK_SIZEOF(void (*) (void)) -GRAS_CHECK_SIZEOF(float) -GRAS_CHECK_SIZEOF(double) -CHECK_IEEE_FP - + AC_MSG_CHECKING(the GRAS signature of this architecture) if test x$endian = x1 ; then trace_endian=B @@ -164,14 +169,40 @@ else fi gras_arch=unknown trace="$trace_endian" -trace="${trace}:${ac_cv_sizeof_char}.${ac_cv_sizeof_short_int}.${ac_cv_sizeof_int}.${ac_cv_sizeof_long_int}.${ac_cv_sizeof_long_long_int}" -trace="${trace}:${ac_cv_sizeof_void_p}.${ac_cv_sizeof_void_LpR_LvoidR}" -trace="${trace}:${ac_cv_sizeof_float}.${ac_cv_sizeof_double}" + +trace="${trace}_C:${ac_cv_sizeof_char}/${ac_cv_struct_boundary_char}:" + +trace="${trace}_I:${ac_cv_sizeof_short_int}/${ac_cv_struct_boundary_short_int}" +trace="${trace}:${ac_cv_sizeof_int}/${ac_cv_struct_boundary_int}" +trace="${trace}:${ac_cv_sizeof_long_int}/${ac_cv_struct_boundary_long_int}" +trace="${trace}:${ac_cv_sizeof_long_long_int}/${ac_cv_struct_boundary_long_long_int}:" + +trace="${trace}_P:${ac_cv_sizeof_void_p}/${ac_cv_struct_boundary_void_p}" +trace="${trace}:${ac_cv_sizeof_void_LpR_LvoidR}/${ac_cv_struct_boundary_void_p}:" + +trace="${trace}_D:4/${ac_cv_struct_boundary_float}:8/${ac_cv_struct_boundary_double}:" + +# sizeof float/double are not tested since IEEE 754 is assumed. +# Check README.IEEE for rational. + +# The numbers after the _ in the arch name are the maximal packing boundary. +# big32_2 means that all data are aligned on a 2 bytes boundary. (ARM) +# big32_8_4 means that some or them are aligned on 8 bytes, some are on 4 bytes (AIX) case $trace in - l:1.2.4.4.8:4.4:4.8) gras_arch=0; gras_arch_name=i386;; - l:1.2.4.8.8:8.8:4.8) gras_arch=1; gras_arch_name=alpha;; - B:1.2.4.4.8:4.4:4.8) gras_arch=2; gras_arch_name=powerpc;; - B:1.2.4.8.8:8.8:4.8) gras_arch=3; gras_arch_name=sparc;; + l_C:1/1:_I:2/1:4/1:4/1:8/1:_P:4/1:4/1:_D:4/1:8/1:) gras_arch=0; gras_size=32; gras_arch_name=little32_1;; + l_C:1/1:_I:2/2:4/2:4/2:8/2:_P:4/2:4/2:_D:4/2:8/2:) gras_arch=1; gras_size=32; gras_arch_name=little32_2;; + l_C:1/1:_I:2/2:4/4:4/4:8/4:_P:4/4:4/4:_D:4/4:8/4:) gras_arch=2; gras_size=32; gras_arch_name=little32_4;; + l_C:1/1:_I:2/2:4/4:4/4:8/8:_P:4/4:4/4:_D:4/4:8/8:) gras_arch=3; gras_size=32; gras_arch_name=little32_8;; + + l_C:1/1:_I:2/2:4/4:8/8:8/8:_P:8/8:8/8:_D:4/4:8/8:) gras_arch=4; gras_size=64; gras_arch_name=little64;; + + B_C:1/1:_I:2/2:4/4:4/4:8/8:_P:4/4:4/4:_D:4/4:8/8:) gras_arch=5; gras_size=32; gras_arch_name=big32;; + B_C:1/1:_I:2/2:4/4:4/4:8/8:_P:4/4:4/4:_D:4/4:8/4:) gras_arch=6; gras_size=32; gras_arch_name=big32_8_4;; + B_C:1/1:_I:2/2:4/4:4/4:8/4:_P:4/4:4/4:_D:4/4:8/4:) gras_arch=7; gras_size=32; gras_arch_name=big32_4;; + B_C:1/1:_I:2/2:4/2:4/2:8/2:_P:4/2:4/2:_D:4/2:8/2:) gras_arch=8; gras_size=32; gras_arch_name=big32_2;; + + B_C:1/1:_I:2/2:4/4:8/8:8/8:_P:8/8:8/8:_D:4/4:8/8:) gras_arch=9; gras_size=64; gras_arch_name=big64;; + B_C:1/1:_I:2/2:4/4:8/8:8/8:_P:8/8:8/8:_D:4/4:8/4:) gras_arch=10;gras_size=64; gras_arch_name=big64_8_4;; esac if test x$gras_arch = xunknown ; then AC_MSG_RESULT([damnit ($trace)]) @@ -179,8 +210,120 @@ if test x$gras_arch = xunknown ; then Please report this architecture trace ($trace) and what it corresponds to.]) fi echo "$as_me:$LINENO: GRAS trace of this machine: $trace" >&AS_MESSAGE_LOG_FD -AC_DEFINE_UNQUOTED(GRAS_THISARCH_NAME,"$gras_arch_name",[defines the GRAS architecture name of this machine]) AC_DEFINE_UNQUOTED(GRAS_THISARCH,$gras_arch,[defines the GRAS architecture signature of this machine]) AC_MSG_RESULT($gras_arch ($gras_arch_name)) + +AM_CONDITIONAL(GRAS_ARCH_32_BITS,[test "$gras_size" = 32]) + +AC_MSG_CHECKING(the maximal size of scalar) +ac_cv_sizeof_max=0 +for s in $ac_cv_sizeof_char \ + $ac_cv_sizeof_short_int $ac_cv_sizeof_int $ac_cv_sizeof_long_int $ac_cv_sizeof_long_long_int \ + $ac_cv_sizeof_void_p $ac_cv_sizeof_void_LpR_LvoidR \ + 4 8; do + + if test $ac_cv_sizeof_max -lt $s ; then + ac_cv_sizeof_max=$s + fi +done +AC_MSG_RESULT($ac_cv_sizeof_max) +AC_DEFINE_UNQUOTED([SIZEOF_MAX],$ac_cv_sizeof_max,[The maximal size of any scalar on this arch]) + ]) # END OF GRAS ARCH CHECK + +AC_DEFUN([GRAS_CHECK_STRUCT_COMPACTION], +[ AC_MSG_CHECKING(whether the struct gets packed) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" + #include + #include /* offsetof() */ + struct s {char c; double d;}; + ]],[[switch (0) + case 0: + case (sizeof(struct s) == sizeof(double)+sizeof(char)):; + ]])],[gras_struct_packed=yes],[gras_struct_packed=no]) + + AC_MSG_RESULT($gras_struct_packed) + if test x$gras_struct_packed = "xyes" ; then + AC_MSG_ERROR([GRAS does not support packed structures since it leads to nasty misalignments]) + fi + + AC_MSG_CHECKING(whether the struct gets compacted) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" + #include + #include /* offsetof() */ + struct s {double d; int i; char c;}; + ]],[[switch (0) + case 0: + case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):; + ]])],[gras_struct_compact=yes],[gras_struct_compact=no]) + + AC_MSG_RESULT($gras_struct_compact) + + if test x$gras_struct_compact != xyes ; then + AC_MSG_ERROR([GRAS works only on structure compacting architectures (yet)]) + fi + AC_DEFINE_UNQUOTED(GRAS_STRUCT_COMPACT, 1, + [Defined if structures are compacted when possible. + + Consider this structure: struct s {double d; int i; char c;}; + + If it is allowed, the char is placed just after the int. If not, + it has to be on the 8 bytes boundary imposed by the double. + + For now, GRAS requires the structures to be compacted. + ]) + AC_MSG_CHECKING(whether arrays can straddle struct alignment boundaries) + + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" + #include + #include /* offsetof() */ + struct s { double d; int i; char c[6]; }; + ]],[[switch (0) + case 0: + case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):; + ]])],[gras_array_straddle_struct=yes],[gras_array_straddle_struct=no]) + + AC_MSG_RESULT($gras_array_straddle_struct) + + if test x$gras_array_straddle_struct = xyes ; then + AC_DEFINE_UNQUOTED(GRAS_ARRAY_STRADDLE_STRUCT, 1, + [Defined if arrays in struct can straddle struct alignment boundaries. + + This is like than the structure compaction above, but this time, + the argument to be compacted is an array whom each element would be + normally compacted. Exemple: + + struct s { double d; int i; char c[6]; }; + + Arrays can straddle if c is allowed to come just after i. + + Note that GRAS only support architecture presenting this + caracteristic so far. + ]) + else + AC_MSG_ERROR([GRAS can only work on architectures allowing array fields to straddle alignment boundaries (yet)]) + fi +]) +# END OF GRAS CHECK STRUCT COMPACTION + +AC_DEFUN([GRAS_C_COMPACT_STRUCT], +[ AC_MSG_CHECKING(whether the struct gets compacted) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" + #include + #include /* offsetof() */ + struct s {double d; int a; int b;}; + ]],[[switch (0) + case 0: + case (offsetof(struct s,b) == sizeof(double)+sizeof(int)):; + ]])],[gras_compact_struct=yes],[gras_compact_struct=no]) + + AC_MSG_RESULT($gras_compact_struct) + + if test x$gras_compact_struct = xyes ; then + AC_DEFINE_UNQUOTED(GRAS_COMPACT_STRUCT, 1, + [Defined if structures are compacted when possible]) + fi +]) +# END OF GRAS COMPACT STRUCT +