Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
change obsolete macros to new ones; do not #define the size of the datatypes, that...
[simgrid.git] / acmacro / gras_arch.m4
index e601623..e5757c3 100644 (file)
@@ -1,3 +1,4 @@
+# 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
@@ -5,17 +6,17 @@ dnl  2: extra include lines
 dnl  3: extra sizes to test
 dnl ("adapted" from openldap)
 dnl
-AC_DEFUN(GRAS_DO_CHECK_SIZEOF,
+AC_DEFUN([GRAS_DO_CHECK_SIZEOF],
 [changequote(<<, >>)dnl 
  dnl The cache variable name (and of the result). 
  define(<<GRAS_CHECK_SIZEOF_RES>>, translit(ac_cv_sizeof_$1, [ *()], [_pLR]))dnl
  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 <sys/types.h> 
    $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 
  ]) 
@@ -28,27 +29,45 @@ dnl  2: extra include lines
 dnl  3: extra sizes to test
 dnl ("adapted" from openldap)
 dnl
-AC_DEFUN(GRAS_CHECK_SIZEOF,
+AC_DEFUN([GRAS_CHECK_SIZEOF],
 [AC_MSG_CHECKING(size of $1) 
 GRAS_DO_CHECK_SIZEOF($1,$2)
 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(<<TYPE_NAME>>, 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_COMPLIMENT([type]): Make sure the type is two-compliment
+dnl warning, this does not work with char (quite logical)
+dnl
+AC_DEFUN([GRAS_TWO_COMPLIMENT],
+[
+AC_MSG_CHECKING(whether $1 is two-compliment)
+AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
+union {
+   signed $1 testInt;
+   unsigned char bytes[sizeof($1)];
+} intTester;
+]],[[
+   intTester.testInt = -2;
+   return ((unsigned int)intTester.bytes[0] +
+          (unsigned int)intTester.bytes[sizeof($1) - 1]) - 509; /* should be 0 */
+]])], dnl end of AC LANG PROGRAM
+[two_compliment=yes],[two_compliment=no] )dnl end of AC COMPILE IFELSE
+
+AC_MSG_RESULT($two_compliment)
+if test x$two_compliment != xyes ; then
+  AC_MSG_ERROR([GRAS works only two-compliment integers (yet)])
+fi
+])
 
 dnl
 dnl GRAS_SIGNED_SIZEOF: Get the size of the datatype, and make sure that
 dnl signed, unsigned and unspecified have the same size
 dnl
-AC_DEFUN(GRAS_SIGNED_SIZEOF,
+AC_DEFUN([GRAS_SIGNED_SIZEOF],
 [AC_MSG_CHECKING(size of $1)
 GRAS_DO_CHECK_SIZEOF($1,$2)
 unspecif=$GRAS_CHECK_SIZEOF_RES
@@ -75,12 +94,6 @@ if test x$unsigned != x$signed ; then
 fi 
 
 AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES) 
-changequote(<<, >>)dnl 
-dnl The name to #define. 
-define(<<TYPE_NAME>>, 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
@@ -90,9 +103,9 @@ dnl
 dnl CHECK_IEEE_FP: determines if floating points are IEEE754 compliant
 dnl (inspired from NWS code)
 dnl
-AC_DEFUN(CHECK_IEEE_FP,
+AC_DEFUN([CHECK_IEEE_FP],
 [AC_MSG_CHECKING(if floating point datatypes are IEEE 754 compliant) 
-AC_TRY_COMPILE([#include "confdefs.h"
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
 union {
         double testFP;
         unsigned char bytes[sizeof(double)];
@@ -101,7 +114,10 @@ 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));
 
@@ -117,25 +133,28 @@ 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
+if (floatTester.testFP != -4.0) return 1;]])],[IEEE_FP=yes],[IEEE_FP=no])
 AC_MSG_RESULT($IEEE_FP)
+
+if test x$IEEE_FP != xyes ; then
+   AC_MSG_ERROR([GRAS works only on IEEE754 compliant systems (yet)])
+else
+   AC_DEFINE(IEEE_FP,1,[defines if this architecture floating point types are IEEE754 compliant])
+fi
 ])dnl end of CHECK_IEEE_FP
 
 
 
 dnl *************************8
 dnl 
-AC_DEFUN(GRAS_ARCH,
+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-compliment arch, since we dunno convert them
+GRAS_TWO_COMPLIMENT(int)
 AC_DEFINE_UNQUOTED(GRAS_BIGENDIAN,$endian,[define if big endian])
-                                                                  
+          
 GRAS_SIGNED_SIZEOF(char)
 GRAS_SIGNED_SIZEOF(short int)
 GRAS_SIGNED_SIZEOF(int)
@@ -149,7 +168,7 @@ 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
@@ -162,7 +181,10 @@ trace="${trace}:${ac_cv_sizeof_char}.${ac_cv_sizeof_short_int}.${ac_cv_sizeof_in
 trace="${trace}:${ac_cv_sizeof_void_p}.${ac_cv_sizeof_void_LpR_LvoidR}"
 trace="${trace}:${ac_cv_sizeof_float}.${ac_cv_sizeof_double}"
 case $trace in
-  l:1.2.4.4.8:4.4:4.8) gras_arch=0; gras_arch_name=i386;;
+  l:1.2.4.4.8:4.4:4.8) gras_arch=0; gras_arch_name=little32;;
+  l:1.2.4.8.8:8.8:4.8) gras_arch=1; gras_arch_name=little64;;
+  B:1.2.4.4.8:4.4:4.8) gras_arch=2; gras_arch_name=big32;;
+  B:1.2.4.8.8:8.8:4.8) gras_arch=3; gras_arch_name=big64;;
 esac
 if test x$gras_arch = xunknown ; then
   AC_MSG_RESULT([damnit ($trace)])
@@ -170,7 +192,115 @@ 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))
 ])
+# 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 <sys/types.h>
+       #include <stddef.h> /* 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 (good)"])
+     
+   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 <sys/types.h>
+       #include <stddef.h> /* 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_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.
+         ])
+     AC_MSG_CHECKING(whether arrays in struct can straddle struct alignment boundaries)
+
+     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
+        #include <sys/types.h>
+       #include <stddef.h> /* 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])
+     else
+       AC_MSG_ERROR([GRAS can only work on either architecture not compacting structures, or allowing array fields to straddle alignment boundaries (yet)])
+     fi
+  fi
+  
+  AC_MSG_CHECKING(for changing alignment boundary structures)
+   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
+        #include <sys/types.h>
+
+       struct s {int i;double d;};
+       ]],[[switch (0) 
+        case 0: 
+        case (sizeof(struct s) == sizeof(double)+sizeof(int)):;
+       ]])],[gras_struct_changing=yes],[gras_struct_changing=no])
+     
+   AC_MSG_RESULT($gras_struct_changing)
+   
+   if test x$gras_struct_changing = xyes ; then
+     AC_DEFINE_UNQUOTED(GRAS_STRUCT_CHANGING, 1,
+          [Defined if the alignment of structures can vary over fields.
+         
+          Consider the following structure:
+            struct s {
+              int i;
+              double d;
+            };
+            
+          On Solaris, sizeof(struct s)=16, ie all fields get aligned to the
+          biggest boundary (and this will not be defined). On Linux,
+           sizeof(struct s)=12 (and this will be defined).
+         ])
+   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 <sys/types.h>
+       #include <stddef.h> /* 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