acmacro/gras_arch.m4

   1 # BEGIN OF GRAS ARCH CHECK
   2 dnl
   3 dnl GRAS_DO_CHECK_SIZEOF: Get the size of a datatype (even in cross-compile)
   4 dnl  1: type tested
   5 dnl  2: extra include lines
   6 dnl  3: extra sizes to test
   7 dnl ("adapted" from openldap)
   8 dnl
   9 AC_DEFUN([GRAS_DO_CHECK_SIZEOF],
  10 [changequote(<<, >>)dnl
  11  dnl The cache variable name (and of the result).
  12  define(<<GRAS_CHECK_SIZEOF_RES>>, translit(ac_cv_sizeof_$1, [ *()], [_pLR]))dnl
  13  changequote([, ])dnl
  14  AC_CACHE_VAL(GRAS_CHECK_SIZEOF_RES,
  15  [for ac_size in 4 8 1 2 16 $3 ; do # List sizes in rough order of prevalence.
  16    AC_COMPILE_IFELSE(AC_LANG_PROGRAM([#include "confdefs.h"
  17    #include <sys/types.h>
  18    $2
  19    ], [switch (0) case 0: case (sizeof ($1) == $ac_size):;]), GRAS_CHECK_SIZEOF_RES=$ac_size)
  20    if test x$GRAS_CHECK_SIZEOF_RES != x ; then break; fi
  21   done
  22  ])
  23 ])
  24
  25 dnl
  26 dnl GRAS_CHECK_SIZEOF: Get the size of a datatype (even in cross-compile), with msg display, and define the result
  27 dnl  1: type tested
  28 dnl  2: extra include lines
  29 dnl  3: extra sizes to test
  30 dnl ("adapted" from openldap)
  31 dnl
  32 AC_DEFUN([GRAS_CHECK_SIZEOF],
  33 [AC_MSG_CHECKING(size of $1)
  34 GRAS_DO_CHECK_SIZEOF($1,$2)
  35 if test x$GRAS_CHECK_SIZEOF_RES = x ; then
  36   AC_MSG_ERROR([cannot determine a size for $1])
  37 fi
  38 AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES)
  39 ])
  40
  41 dnl
  42 dnl GRAS_TWO_COMPLEMENT([type]): Make sure the type is two-complement
  43 dnl warning, this does not work with char (quite logical)
  44 dnl
  45 AC_DEFUN([GRAS_TWO_COMPLEMENT],
  46 [
  47 AC_MSG_CHECKING(whether $1 is two-complement)
  48 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
  49 union {
  50    signed $1 testInt;
  51    unsigned char bytes[sizeof($1)];
  52 } intTester;
  53 ]],[[
  54    intTester.testInt = -2;
  55    switch (0) {
  56     case 0:
  57     case (((unsigned int)intTester.bytes[0] +
  58            (unsigned int)intTester.bytes[sizeof($1) - 1]) - 509) == 0:
  59    }
  60 ]])], dnl end of AC LANG PROGRAM
  61 [two_complement=yes],[two_complement=no] )dnl end of AC COMPILE IFELSE
  62
  63 AC_MSG_RESULT($two_complement)
  64 if test x$two_complement != xyes ; then
  65   AC_MSG_ERROR([GRAS works only two-complement integers (yet)])
  66 fi
  67 ])
  68
  69 dnl
  70 dnl GRAS_SIGNED_SIZEOF: Get the size of the datatype, and make sure that
  71 dnl signed, unsigned and unspecified have the same size
  72 dnl
  73 AC_DEFUN([GRAS_SIGNED_SIZEOF],
  74 [AC_MSG_CHECKING(size of $1)
  75 GRAS_DO_CHECK_SIZEOF($1,$2)
  76 unspecif=$GRAS_CHECK_SIZEOF_RES
  77 if test x$unspecif = x ; then
  78   AC_MSG_ERROR([cannot determine a size for $1])
  79 fi
  80
  81 GRAS_DO_CHECK_SIZEOF(signed $1,$2)
  82 signed=$GRAS_CHECK_SIZEOF_RES
  83 if test x$signed = x ; then
  84   AC_MSG_ERROR([cannot determine a size for signed $1])
  85 fi
  86 if test x$unspecif != x$signed ; then
  87   AC_MSG_ERROR(['signed $1' and '$1' have different sizes ! ($signed != $unspecif)])
  88 fi
  89
  90 GRAS_DO_CHECK_SIZEOF(unsigned $1,$2)
  91 unsigned=$GRAS_CHECK_SIZEOF_RES
  92 if test x$unsigned = x ; then
  93   AC_MSG_ERROR([cannot determine a size for unsigned $1])
  94 fi
  95 if test x$unsigned != x$signed ; then
  96   AC_MSG_ERROR(['signed $1' and 'unsigned $1' have different sizes ! ($signed != $unsigned)])
  97 fi
  98
  99 AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES)
 100 ])
 101
 102 dnl
 103 dnl End of CHECK_SIGNED_SIZEOF
 104 dnl
 105
 106 # GRAS_STRUCT_BOUNDARY(): Check the minimal alignment boundary of $1 in structures
 107 # ---------------------
 108 # (using integer, I hope no arch let it change with the content)
 109 AC_DEFUN([GRAS_STRUCT_BOUNDARY],
 110 [changequote(<<, >>)dnl
 111  dnl The cache variable name (and of the result).
 112  define(<<GRAS_STRUCT_BOUNDARY_RES>>, translit(ac_cv_struct_boundary_$1, [ *()], [_pLR]))dnl
 113  changequote([, ])dnl
 114  AC_MSG_CHECKING(for the minimal structure boundary of $1)
 115
 116  AC_CACHE_VAL(GRAS_STRUCT_BOUNDARY_RES,
 117  [for ac_size in 1 2 4 8 16 32 64 ; do # List sizes in rough order of prevalence.
 118    AC_COMPILE_IFELSE(AC_LANG_PROGRAM([#include "confdefs.h"
 119      #include <sys/types.h>
 120      struct s { char c; $1 i; };
 121      ],[switch (0) case 0: case (sizeof (struct s) == $ac_size+sizeof($1)):;]), GRAS_STRUCT_BOUNDARY_RES=$ac_size)
 122    if test x$GRAS_STRUCT_BOUNDARY_RES != x ; then break; fi
 123   done
 124  ])
 125  AC_MSG_RESULT($GRAS_STRUCT_BOUNDARY_RES)
 126  if test x$GRAS_STRUCT_BOUNDARY_RES = x ; then
 127    AC_MSG_ERROR([Cannot determine the minimal alignment boundary of $1 in structures])
 128  fi
 129 ])
 130
 131 # GRAS_ARCH(): check the gras_architecture of this plateform
 132 # -----------
 133 # The different cases here must be syncronized with the array in src/base/DataDesc/ddt_convert.c
 134 #
 135 AC_DEFUN([GRAS_ARCH],
 136 [
 137 # Check for the architecture
 138 AC_C_BIGENDIAN(endian=1,endian=0,AC_MSG_ERROR([GRAS works only for little or big endian systems (yet)]))
 139 dnl Make sure we don't run on a non-two-complement arch, since we dunno convert them
 140 dnl G RAS_TWO_COMPLEMENT(int) don't do this, it breaks cross-compile and all
 141 dnl archs conform to this
 142 AC_DEFINE_UNQUOTED(GRAS_BIGENDIAN,$endian,[define if big endian])
 143
 144 GRAS_SIGNED_SIZEOF(char)              GRAS_STRUCT_BOUNDARY(char)
 145 GRAS_SIGNED_SIZEOF(short int)         GRAS_STRUCT_BOUNDARY(short int)
 146 GRAS_SIGNED_SIZEOF(int)               GRAS_STRUCT_BOUNDARY(int)
 147 GRAS_SIGNED_SIZEOF(long int)          GRAS_STRUCT_BOUNDARY(long int)
 148 GRAS_SIGNED_SIZEOF(long long int)     GRAS_STRUCT_BOUNDARY(long long int)
 149
 150 GRAS_STRUCT_BOUNDARY(float)           GRAS_STRUCT_BOUNDARY(double)
 151
 152 GRAS_CHECK_SIZEOF(void *)             GRAS_STRUCT_BOUNDARY(void *)
 153 GRAS_CHECK_SIZEOF(void (*) (void))
 154
 155
 156 AC_MSG_CHECKING(the GRAS signature of this architecture)
 157 if test x$endian = x1 ; then
 158   trace_endian=B
 159 else
 160   trace_endian=l
 161 fi
 162 gras_arch=unknown
 163 trace="$trace_endian"
 164
 165 trace="${trace}_C:${ac_cv_sizeof_char}/${ac_cv_struct_boundary_char}:"
 166
 167 trace="${trace}_I:${ac_cv_sizeof_short_int}/${ac_cv_struct_boundary_short_int}"
 168 trace="${trace}:${ac_cv_sizeof_int}/${ac_cv_struct_boundary_int}"
 169 trace="${trace}:${ac_cv_sizeof_long_int}/${ac_cv_struct_boundary_long_int}"
 170 trace="${trace}:${ac_cv_sizeof_long_long_int}/${ac_cv_struct_boundary_long_long_int}:"
 171
 172 trace="${trace}_P:${ac_cv_sizeof_void_p}/${ac_cv_struct_boundary_void_p}"
 173 trace="${trace}:${ac_cv_sizeof_void_LpR_LvoidR}/${ac_cv_struct_boundary_void_p}:"
 174
 175 trace="${trace}_D:4/${ac_cv_struct_boundary_float}:8/${ac_cv_struct_boundary_double}:"
 176
 177 # sizeof float/double are not tested since IEEE 754 is assumed.
 178 # Check README.IEEE for rational.
 179 case $trace in
 180   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=0; gras_arch_name=little32;;
 181   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=1; gras_arch_name=little64;;
 182   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=2; gras_arch_name=big32;;
 183   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=3; gras_arch_name=big64;;
 184   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=4; gras_arch_name=aix;;
 185   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=5; gras_arch_name=arm;;
 186   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=6; gras_arch_name=win32;;
 187 esac
 188 if test x$gras_arch = xunknown ; then
 189   AC_MSG_RESULT([damnit ($trace)])
 190   AC_MSG_ERROR([Impossible to determine the GRAS architecture signature.
 191 Please report this architecture trace ($trace) and what it corresponds to.])
 192 fi
 193 echo "$as_me:$LINENO: GRAS trace of this machine: $trace" >&AS_MESSAGE_LOG_FD
 194 AC_DEFINE_UNQUOTED(GRAS_THISARCH,$gras_arch,[defines the GRAS architecture signature of this machine])
 195 AC_MSG_RESULT($gras_arch ($gras_arch_name))
 196 ])
 197 # END OF GRAS ARCH CHECK
 198
 199 AC_DEFUN([GRAS_CHECK_STRUCT_COMPACTION],
 200 [  AC_MSG_CHECKING(whether the struct gets packed)
 201    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
 202         #include <sys/types.h>
 203         #include <stddef.h> /* offsetof() */
 204         struct s {char c; double d;};
 205        ]],[[switch (0)
 206         case 0:
 207         case (sizeof(struct s) == sizeof(double)+sizeof(char)):;
 208        ]])],[gras_struct_packed=yes],[gras_struct_packed=no])
 209
 210    AC_MSG_RESULT($gras_struct_packed)
 211    if test x$gras_struct_packed = "xyes" ; then
 212      AC_MSG_ERROR([GRAS does not support packed structures since it leads to nasty misalignments])
 213    fi
 214
 215    AC_MSG_CHECKING(whether the struct gets compacted)
 216    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
 217         #include <sys/types.h>
 218         #include <stddef.h> /* offsetof() */
 219         struct s {double d; int i; char c;};
 220        ]],[[switch (0)
 221         case 0:
 222         case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):;
 223        ]])],[gras_struct_compact=yes],[gras_struct_compact=no])
 224
 225    AC_MSG_RESULT($gras_struct_compact)
 226
 227    if test x$gras_struct_compact != xyes ; then
 228      AC_MSG_ERROR([GRAS works only on structure compacting architectures (yet)])
 229    fi
 230    AC_DEFINE_UNQUOTED(GRAS_STRUCT_COMPACT, 1,
 231       [Defined if structures are compacted when possible.
 232
 233        Consider this structure: struct s {double d; int i; char c;};
 234
 235        If it is allowed, the char is placed just after the int. If not,
 236        it has to be on the 8 bytes boundary imposed by the double.
 237
 238        For now, GRAS requires the structures to be compacted.
 239       ])
 240    AC_MSG_CHECKING(whether arrays can straddle struct alignment boundaries)
 241
 242    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
 243       #include <sys/types.h>
 244         #include <stddef.h> /* offsetof() */
 245         struct s { double d; int i; char c[6]; };
 246      ]],[[switch (0)
 247       case 0:
 248       case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):;
 249      ]])],[gras_array_straddle_struct=yes],[gras_array_straddle_struct=no])
 250
 251    AC_MSG_RESULT($gras_array_straddle_struct)
 252
 253    if test x$gras_array_straddle_struct = xyes ; then
 254      AC_DEFINE_UNQUOTED(GRAS_ARRAY_STRADDLE_STRUCT, 1,
 255         [Defined if arrays in struct can straddle struct alignment boundaries.
 256
 257          This is like than the structure compaction above, but this time,
 258          the argument to be compacted is an array whom each element would be
 259          normally compacted. Exemple:
 260
 261          struct s { double d; int i; char c[6]; };
 262
 263          Arrays can straddle if c is allowed to come just after i.
 264
 265          Note that GRAS only support architecture presenting this
 266          caracteristic so far.
 267         ])
 268    else
 269      AC_MSG_ERROR([GRAS can only work on architectures allowing array fields to straddle alignment boundaries (yet)])
 270    fi
 271 ])
 272 # END OF GRAS CHECK STRUCT COMPACTION
 273
 274 AC_DEFUN([GRAS_C_COMPACT_STRUCT],
 275 [  AC_MSG_CHECKING(whether the struct gets compacted)
 276    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
 277         #include <sys/types.h>
 278         #include <stddef.h> /* offsetof() */
 279         struct s {double d; int a; int b;};
 280        ]],[[switch (0)
 281         case 0:
 282         case (offsetof(struct s,b) == sizeof(double)+sizeof(int)):;
 283        ]])],[gras_compact_struct=yes],[gras_compact_struct=no])
 284
 285    AC_MSG_RESULT($gras_compact_struct)
 286
 287    if test x$gras_compact_struct = xyes ; then
 288      AC_DEFINE_UNQUOTED(GRAS_COMPACT_STRUCT, 1,
 289           [Defined if structures are compacted when possible])
 290    fi
 291 ])
 292 # END OF GRAS COMPACT STRUCT
 293