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
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_COMPLIMENT([type]): Make sure the type is two-compliment
43 dnl warning, this does not work with char (quite logical)
44 dnl
45 AC_DEFUN([GRAS_TWO_COMPLIMENT],
46 [
47 AC_MSG_CHECKING(whether $1 is two-compliment)
48 AC_RUN_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    return ((unsigned int)intTester.bytes[0] +
56            (unsigned int)intTester.bytes[sizeof($1) - 1]) - 509; /* should be 0 */
57 ]])], dnl end of AC LANG PROGRAM
58 [two_compliment=yes],[two_compliment=no] )dnl end of AC COMPILE IFELSE
59
60 AC_MSG_RESULT($two_compliment)
61 if test x$two_compliment != xyes ; then
62   AC_MSG_ERROR([GRAS works only two-compliment integers (yet)])
63 fi
64 ])
65
66 dnl
67 dnl GRAS_SIGNED_SIZEOF: Get the size of the datatype, and make sure that
68 dnl signed, unsigned and unspecified have the same size
69 dnl
70 AC_DEFUN([GRAS_SIGNED_SIZEOF],
71 [AC_MSG_CHECKING(size of $1)
72 GRAS_DO_CHECK_SIZEOF($1,$2)
73 unspecif=$GRAS_CHECK_SIZEOF_RES
74 if test x$unspecif = x ; then
75   AC_MSG_ERROR([cannot determine a size for $1]) 
76 fi 
77
78 GRAS_DO_CHECK_SIZEOF(signed $1,$2)
79 signed=$GRAS_CHECK_SIZEOF_RES
80 if test x$signed = x ; then
81   AC_MSG_ERROR([cannot determine a size for signed $1]) 
82 fi 
83 if test x$unspecif != x$signed ; then
84   AC_MSG_ERROR(['signed $1' and '$1' have different sizes ! ($signed != $unspecif)]) 
85 fi 
86
87 GRAS_DO_CHECK_SIZEOF(unsigned $1,$2)
88 unsigned=$GRAS_CHECK_SIZEOF_RES
89 if test x$unsigned = x ; then
90   AC_MSG_ERROR([cannot determine a size for unsigned $1]) 
91 fi 
92 if test x$unsigned != x$signed ; then
93   AC_MSG_ERROR(['signed $1' and 'unsigned $1' have different sizes ! ($signed != $unsigned)]) 
94 fi 
95
96 AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES) 
97 ])
98
99 dnl
100 dnl End of CHECK_SIGNED_SIZEOF
101 dnl
102
103 dnl CHECK_IEEE_FP: determines if floating points are IEEE754 compliant
104 dnl (inspired from NWS code)
105 dnl
106 AC_DEFUN([CHECK_IEEE_FP],
107 [AC_MSG_CHECKING(if floating point datatypes are IEEE 754 compliant) 
108 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
109 union {
110         double testFP;
111         unsigned char bytes[sizeof(double)];
112 } doubleTester;
113 union {
114         float testFP;
115         unsigned char bytes[sizeof(float)];
116 } floatTester;
117 ]],[[
118 if (sizeof(double) != 8 || sizeof(float) != 4)
119    return 1;
120
121 memset(&doubleTester, 0, sizeof(doubleTester));
122 memset(&floatTester, 0, sizeof(floatTester));
123
124 doubleTester.bytes[GRAS_BIGENDIAN ? sizeof(double) - 1 : 0]=192;
125 doubleTester.bytes[GRAS_BIGENDIAN ? sizeof(double) - 2 : 1] =
126   (sizeof(double) == 4)  ? 128 :
127   (sizeof(double) == 8)  ? 16 :
128   (sizeof(double) == 16) ? 1 : 0;
129 if (doubleTester.testFP != -4.0) return 1;
130
131 floatTester.bytes[GRAS_BIGENDIAN ? sizeof(float) - 1 : 0]=192;
132 floatTester.bytes[GRAS_BIGENDIAN ? sizeof(float) - 2 : 1] =
133   (sizeof(float) == 4)  ? 128 :
134   (sizeof(float) == 8)  ? 16 :
135   (sizeof(float) == 16) ? 1 : 0;
136 if (floatTester.testFP != -4.0) return 1;]])],[IEEE_FP=yes],[IEEE_FP=no])
137 AC_MSG_RESULT($IEEE_FP)
138
139 if test x$IEEE_FP != xyes ; then
140    AC_MSG_ERROR([GRAS works only on IEEE754 compliant systems (yet)])
141 else
142    AC_DEFINE(IEEE_FP,1,[defines if this architecture floating point types are IEEE754 compliant])
143 fi
144 ])dnl end of CHECK_IEEE_FP
145
146
147
148 dnl *************************8
149 dnl 
150 AC_DEFUN([GRAS_ARCH],
151 [
152 # Check for the architecture
153 AC_C_BIGENDIAN(endian=1,endian=0,AC_MSG_ERROR([GRAS works only for little or big endian systems (yet)]))
154 dnl Make sure we don't run on a non-two-compliment arch, since we dunno convert them
155 GRAS_TWO_COMPLIMENT(int)
156 AC_DEFINE_UNQUOTED(GRAS_BIGENDIAN,$endian,[define if big endian])
157           
158 GRAS_SIGNED_SIZEOF(char)
159 GRAS_SIGNED_SIZEOF(short int)
160 GRAS_SIGNED_SIZEOF(int)
161 GRAS_SIGNED_SIZEOF(long int)
162 GRAS_SIGNED_SIZEOF(long long int)
163                                                                   
164
165 GRAS_CHECK_SIZEOF(void *)
166 GRAS_CHECK_SIZEOF(void (*) (void))
167                                                                   
168 GRAS_CHECK_SIZEOF(float)
169 GRAS_CHECK_SIZEOF(double)
170 CHECK_IEEE_FP
171
172 AC_MSG_CHECKING(the GRAS signature of this architecture)
173 if test x$endian = x1 ; then
174   trace_endian=B
175 else
176   trace_endian=l
177 fi
178 gras_arch=unknown
179 trace="$trace_endian"
180 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}"
181 trace="${trace}:${ac_cv_sizeof_void_p}.${ac_cv_sizeof_void_LpR_LvoidR}"
182 trace="${trace}:${ac_cv_sizeof_float}.${ac_cv_sizeof_double}"
183 case $trace in
184   l:1.2.4.4.8:4.4:4.8) gras_arch=0; gras_arch_name=little32;;
185   l:1.2.4.8.8:8.8:4.8) gras_arch=1; gras_arch_name=little64;;
186   B:1.2.4.4.8:4.4:4.8) gras_arch=2; gras_arch_name=big32;;
187   B:1.2.4.8.8:8.8:4.8) gras_arch=3; gras_arch_name=big64;;
188 esac
189 if test x$gras_arch = xunknown ; then
190   AC_MSG_RESULT([damnit ($trace)])
191   AC_MSG_ERROR([Impossible to determine the GRAS architecture signature.
192 Please report this architecture trace ($trace) and what it corresponds to.])
193 fi
194 echo "$as_me:$LINENO: GRAS trace of this machine: $trace" >&AS_MESSAGE_LOG_FD
195 AC_DEFINE_UNQUOTED(GRAS_THISARCH,$gras_arch,[defines the GRAS architecture signature of this machine])
196 AC_MSG_RESULT($gras_arch ($gras_arch_name))
197 ])
198 # END OF GRAS ARCH CHECK
199
200 AC_DEFUN([GRAS_CHECK_STRUCT_COMPACTION],
201 [  AC_MSG_CHECKING(whether the struct gets packed)
202    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
203         #include <sys/types.h>
204         #include <stddef.h> /* offsetof() */
205         struct s {char c; double d;}; 
206        ]],[[switch (0) 
207         case 0: 
208         case (sizeof(struct s) == sizeof(double)+sizeof(char)):;
209        ]])],[gras_struct_packed=yes],[gras_struct_packed="no (good)"])
210      
211    AC_MSG_RESULT($gras_struct_packed)
212    if test x$gras_struct_packed = xyes ; then
213      AC_MSG_ERROR([GRAS does not support packed structures since it leads to nasty misalignments])
214    fi
215    
216    AC_MSG_CHECKING(whether the struct gets compacted)
217    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
218         #include <sys/types.h>
219         #include <stddef.h> /* offsetof() */
220         struct s {double d; int i; char c;}; 
221        ]],[[switch (0) 
222         case 0: 
223         case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):;
224        ]])],[gras_struct_compact=yes],[gras_struct_compact=no])
225      
226    AC_MSG_RESULT($gras_struct_compact)
227    
228    if test x$gras_struct_compact = xyes ; then
229      AC_DEFINE_UNQUOTED(GRAS_STRUCT_COMPACT, 1,
230           [Defined if structures are compacted when possible.
231           
232           Consider this structure: struct s {double d; int i; char c;}; 
233           
234           If it is allowed, the char is placed just after the int. If not,
235           it has to be on the 8 bytes boundary imposed by the double.
236           ])
237      AC_MSG_CHECKING(whether arrays in struct can straddle struct alignment boundaries)
238
239      AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
240         #include <sys/types.h>
241         #include <stddef.h> /* offsetof() */
242         struct s { double d; int i; char c[6]; };
243        ]],[[switch (0) 
244         case 0: 
245         case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):;
246        ]])],[gras_array_straddle_struct=yes],[gras_array_straddle_struct=no])
247        
248      AC_MSG_RESULT($gras_array_straddle_struct)
249
250      if test x$gras_array_straddle_struct = xyes ; then
251        AC_DEFINE_UNQUOTED(GRAS_ARRAY_STRADDLE_STRUCT, 1,
252             [Defined if arrays in struct can straddle struct alignment boundaries])
253      else
254        AC_MSG_ERROR([GRAS can only work on either architecture not compacting structures, or allowing array fields to straddle alignment boundaries (yet)])
255      fi
256   fi
257   
258   AC_MSG_CHECKING(for changing alignment boundary structures)
259    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
260         #include <sys/types.h>
261
262         struct s {int i;double d;};
263        ]],[[switch (0) 
264         case 0: 
265         case (sizeof(struct s) == sizeof(double)+sizeof(int)):;
266        ]])],[gras_struct_changing=yes],[gras_struct_changing=no])
267      
268    AC_MSG_RESULT($gras_struct_changing)
269    
270    if test x$gras_struct_changing = xyes ; then
271      AC_DEFINE_UNQUOTED(GRAS_STRUCT_CHANGING, 1,
272           [Defined if the alignment of structures can vary over fields.
273           
274            Consider the following structure:
275              struct s {
276                int i;
277                double d;
278              };
279              
280            On Solaris, sizeof(struct s)=16, ie all fields get aligned to the
281            biggest boundary (and this will not be defined). On Linux,
282            sizeof(struct s)=12 (and this will be defined).
283           ])
284    fi
285 ])
286 # END OF GRAS CHECK STRUCT COMPACTION
287
288 AC_DEFUN([GRAS_C_COMPACT_STRUCT],
289 [  AC_MSG_CHECKING(whether the struct gets compacted)
290    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h" 
291         #include <sys/types.h>
292         #include <stddef.h> /* offsetof() */
293         struct s {double d; int a; int b;}; 
294        ]],[[switch (0) 
295         case 0: 
296         case (offsetof(struct s,b) == sizeof(double)+sizeof(int)):;
297        ]])],[gras_compact_struct=yes],[gras_compact_struct=no])
298      
299    AC_MSG_RESULT($gras_compact_struct)
300    
301    if test x$gras_compact_struct = xyes ; then
302      AC_DEFINE_UNQUOTED(GRAS_COMPACT_STRUCT, 1,
303           [Defined if structures are compacted when possible])
304    fi     
305 ])
306 # END OF GRAS COMPACT STRUCT