Core: Add mechanisms to test for address space randomization
[charm.git] / src / scripts / configure.in
1
2 AC_INIT(./Makefile)
3
4 AC_CONFIG_HEADER(conv-autoconfig.h)
5
6 CHARMINC="."
7 test -r ./conv-config.sh && . ./conv-config.sh
8
9 #keep it a decimal
10 VERSION=60100
11 echo $VERSION > ../include/VERSION
12 AC_DEFINE_UNQUOTED([CHARM_VERSION], $VERSION, [Charm++ version number])
13
14 AC_MSG_CHECKING(machine name)
15 version=`pwd | awk -F/ '{print $(NF-1)}'`
16 base_version=`cat .vdir`
17 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
18 AC_MSG_RESULT($version)
19 AC_SUBST(base_version)
20
21 t="test.cpp"
22 tc="test.c"
23
24 charmout="charmconfig.out"
25 /bin/rm -rf $charmout
26
27 # test result passed in $1
28 # If the test suceeded, print $3 and set "pass"/clear "fail"
29 # If the test failed, print $2 and clear "pass"/set "fail"
30 test_result() {
31         if test $1 -eq 0
32         then
33                 AC_MSG_RESULT("$3")
34                 pass="1"
35                 fail="0"
36         else
37                 AC_MSG_RESULT("$4")
38                 pass="0"
39                 fail="1"
40 # For debugging the configure script, just "export autoconf_debug=1"
41 #  to get this verbose data on any failed tests:
42                 if test ! -z "$autoconf_debug"
43                 then
44                         echo "------- test script for $2 failed:"
45                         cat out
46                         echo "------- the test program was:"
47                         cat $t
48                         echo "-------"
49                 fi
50         fi
51 }
52
53 # Test: tries to compile C file $t (described by $1).
54 #  If successful, prints $2 and sets $pass/clears $fail
55 #  If failure, prints $3 and sets $pass/clears $fail
56 #  additional arguments to c++ compiler are passed as $4
57 test_cc() {
58         AC_MSG_CHECKING("$1")
59         echo "### $1" >> $charmout
60         cat $tc >> $charmout
61         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
62         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
63         test_result $? "$1" "$2" "$3"
64         strictpass=$pass
65         strictfail=$fail
66         if test $pass -eq 1
67         then 
68           if cat out | grep -i "warn" > /dev/null 2>&1
69           then 
70             strictpass="0" && strictfail="1"
71           fi
72         fi
73         cat out >> $charmout
74         /bin/rm -f out
75 }
76
77 # Test: tries to compile C++ file $t (described by $1).
78 #  If successful, prints $2 and sets $pass/clears $fail
79 #  If failure, prints $3 and sets $pass/clears $fail
80 #  additional arguments to c++ compiler are passed as $4
81 test_cxx() {
82         AC_MSG_CHECKING("$1")
83         echo "### $1" >> $charmout
84         cat $t >> $charmout
85         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
86         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
87         test_result $? "$1" "$2" "$3"
88         strictpass=$pass
89         strictfail=$fail
90         if test $pass -eq 1
91         then 
92           if cat out | grep -i "warn" > /dev/null 2>&1
93           then 
94             strictpass="0" && strictfail="1"
95           fi
96         fi
97         cat out >> $charmout
98         /bin/rm -f out
99 }
100
101 # Testlink: tries to compile and link a C++ file $t (described by $1).
102 #  If successful, prints $2 and sets $pass/clears $fail
103 #  If failure, prints $3 and sets $pass/clears $fail
104 #  additional arguments to c++ compiler are passed as $4
105 test_link() {
106         AC_MSG_CHECKING("$1")
107         echo "### $1" >> $charmout
108         cat $t >> $charmout
109         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
110         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
111         if test $? -ne 0
112         then
113           test_result 1 "$1" "$2" "$3"
114         else
115           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
116           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
117           ret=$?
118           test ! -x testlink && ret=1
119           test_result $ret "$1" "$2" "$3"
120         fi
121         strictpass=$pass
122         strictfail=$fail
123         if test $pass -eq 1
124         then 
125           if cat out | grep -i "warn" > /dev/null 2>&1
126           then 
127             strictpass="0" && strictfail="1"
128           fi
129         fi
130         cat out >> $charmout
131         /bin/rm -f out
132 }
133
134 # Testlinkc: tries to compile and link a C file $t (described by $1).
135 #  If successful, prints $2 and sets $pass/clears $fail
136 #  If failure, prints $3 and sets $pass/clears $fail
137 #  additional arguments to c++ compiler are passed as $4
138 test_linkc() {
139         AC_MSG_CHECKING("$1")
140         echo "### $1" >> $charmout
141         cat $tc >> $charmout
142         echo $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 >> $charmout
143         $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 > out 2>&1
144         if test $? -ne 0
145         then
146           test_result 1 "$1" "$2" "$3"
147         else
148           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
149           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
150           test_result $? "$1" "$2" "$3"
151         fi
152         strictpass=$pass
153         strictfail=$fail
154         if test $pass -eq 1
155         then 
156           if cat out | grep -i "warn" > /dev/null 2>&1
157           then 
158             strictpass="0" && strictfail="1"
159           fi
160         fi
161         cat out >> $charmout
162         /bin/rm -f out
163 }
164
165 # test_linkso $1 $2 $3 $4, where
166 # $1: debug msg
167 # $2: yes msg
168 # $3: no msg
169 # $4: extra link option
170 test_linkso() {
171         AC_MSG_CHECKING("$1")
172         echo $1 >> $charmout
173         cat $t >> $charmout
174         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
175         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
176         if test $? = 1
177         then
178           test_result 1 "$1" "$2" "$3"
179         else
180           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
181           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
182           test_result $? "$1" "$2" "$3"
183         fi
184         cat out >> $charmout
185         /bin/rm -f out testlink.$CMK_SHARED_SUF
186 }
187
188 # add into conv-mach-opt.sh
189 # add_flag $1 $2
190 # $2 is description
191 add_flag() {
192         key=`echo $1 | cut -d'=' -f1`
193         last=`grep $key ../include/conv-mach-opt.sh 2>/dev/null | tail -1`
194         skip=0
195         if test -n "$last" -a  "$last" = "$1" 
196         then
197           skip=1
198         fi
199         if test $skip = 0
200         then
201           cat >> ../include/conv-mach-opt.sh << EOT
202
203 # Option added by configure script's $2 section
204 $1
205
206 EOT
207         fi
208 }
209
210 test_finish() {
211         rm -f $t $tc testlink test.o    > /dev/null 2>&1
212         /bin/rm -f out
213         exit $1
214 }
215
216 # try to decide the version of glibc
217 get_glibc_version() {
218 t=test.c
219 cat > $t <<EOT
220 #include <stdio.h>
221 #include <gnu/libc-version.h>
222 int main (void) { puts (gnu_get_libc_version ()); return 0; }
223 EOT
224 gcc -o gver test.c
225 GLIBCVERSION=`./gver`
226 /bin/rm -f $t gver
227 }
228
229 cat > $t <<EOT
230 #include <stdio.h>
231 void foo(void) {
232         printf("Hello, world!\n");
233 }
234 EOT
235 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
236 AC_MSG_CHECKING("C++ compiler as")
237 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX $OPTS")
238 test_cxx "whether C++ compiler works" "ok" "no" ""
239 if test $fail -eq 1
240 then
241         echo "Cannot compile C++ programs with $CMK_CXX"
242         echo " (check your charm++ version)"
243         test_finish 1
244 fi
245
246 cat > $t <<EOT
247 #include <stdio.h>
248 int main() {
249         printf("Hello, world!\n");
250         return 0;
251 }
252 EOT
253 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
254 AC_MSG_CHECKING("C++ linker as")
255 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
256 test_link "whether linker works" "ok" "no" ""
257 if test $fail -eq 1
258 then
259         echo "Cannot link C++ programs with $CMK_LDXX"
260         echo " (check your charm++ version)"
261         test_finish 1
262 fi
263
264 if test "$base_version" = "net-linux" 
265 then
266   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
267   if test $pass -eq 1
268   then
269         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
270   fi
271 fi
272
273 # Perform the tests
274
275 #### Check if compiler if 64 bit ####
276 cat > $t <<EOT
277 #include <stdio.h>
278
279 int foo()
280 {
281 int x[[sizeof(void *) - 7]];
282 return x[[0]];
283 }
284 EOT
285 test_cxx "whether compiler is 64bit" "yes" "no" ""
286 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
287
288
289 #### check strings.h ####
290 cat > $t <<EOT
291 #include <strings.h>
292 int main() { 
293   char str[[8]];
294   bzero(str, 8);
295   return 0;
296 }
297 EOT
298 test_cxx "whether has strings.h " "yes" "no" ""
299 AC_DEFINE_UNQUOTED(CMK_HAS_STRINGS_H, $pass, [whether has strings.h])
300
301 #### test if has values.h ####
302 cat > $t <<EOT
303 #include <values.h>
304 int main() { 
305   double d = MAXDOUBLE;
306   return 0;
307 }
308 EOT
309 test_cxx "whether has values.h " "yes" "no" ""
310 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
311
312 #### test if has stdint.h ####
313 cat > $t <<EOT
314 #include <stdint.h>
315 int main() { 
316   return 0;
317 }
318 EOT
319 test_cxx "whether has stdint.h " "yes" "no" ""
320 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
321
322 #### test if has malloc.h ####
323 cat > $t <<EOT
324 #include <malloc.h>
325 int main() { 
326   return 0;
327 }
328 EOT
329 test_cxx "whether has malloc.h " "yes" "no" ""
330 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
331
332 #### test if has alloca.h ####
333 cat > $t <<EOT
334 #include <alloca.h>
335 int main() {
336   double *s=(double *)alloca(sizeof(double));
337   *s=1.0;
338   return 0;
339 }
340 EOT
341 test_cxx "whether has alloca.h " "yes" "no" ""
342 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
343
344 #### test if has regex.h ####
345 cat > $t <<EOT
346 #include <regex.h>
347 int main() {
348   regex_t re;
349   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
350   return 0;
351 }
352 EOT
353 test_cxx "whether has regex.h " "yes" "no" ""
354 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
355
356 #### Check bool ####
357 cat > $t <<EOT
358 #include <stdlib.h>
359 bool foo(void) { return true; }
360 EOT
361 test_cxx "whether C++ bool works" "ok" "no" ""
362 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
363
364 #### Check long long ####
365 cat > $t <<EOT
366 #include <stdlib.h>
367 long long foo(void) { return 17; }
368 EOT
369 test_cxx "whether long long works" "ok" "no" ""
370 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
371
372 #### Check __int64 ####
373 cat > $t <<EOT
374 #include <stdlib.h>
375 __int64 foo(void) { return 17; }
376 EOT
377 test_cxx "whether __int64 works" "ok" "no" ""
378 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], 1, [whether __int64 works])
379
380 #### Check long double ####
381 cat > $t <<EOT
382 #include <stdlib.h>
383 long double foo(void) { return 17.0; }
384 EOT
385 test_cxx "whether long double works" "ok" "no" ""
386 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
387
388 #### Check ucontext and FPU pointer ####
389 cat > $t <<EOT
390 #include <ucontext.h>
391 struct _libc_fpstate   fpstate;
392 fpregset_t *fp;
393 EOT
394 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
395 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
396
397 if test $pass -eq 1
398 then
399 cat > $t <<EOT
400 #include <ucontext.h>
401
402 int main()
403 {
404   ucontext_t context;
405   context.uc_mcontext.uc_regs = 0;
406 }
407 EOT
408 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
409 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
410 fi
411
412 cat > $t <<EOT
413 #include <ucontext.h>
414 vrregset_t *v_regs;
415 ucontext_t  uc;
416
417 void foo()
418 {
419   vrregset_t *ptr = uc.uc_mcontext.v_regs;
420 }
421 EOT
422 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
423 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
424
425 ###################### C++ Compiler Features #####################
426
427 #### check C inline ####
428 cat > $tc <<EOT
429 inline static int foo()
430 {
431   return 1;
432 }
433 EOT
434 test_cc "whether inline works in C" "yes" "no" ""
435 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
436
437 #### check explicit ####
438 cat > $t <<EOT
439 #include <stdlib.h>
440 class er {
441  protected:
442    explicit er(unsigned int inType) {};
443 };
444 EOT
445 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
446 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
447
448 #### check if signed char is same as char ####
449 cat > $t <<EOT
450 #include <stdlib.h>
451 class er {
452  protected:
453    void operator()(char &v,const char *desc=NULL) {};
454    void operator()(signed char &v,const char *desc=NULL) {};
455 };
456 EOT
457 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
458 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
459
460 #### check if C++ casts work ####
461 cat > $t <<EOT
462 int foo(float *t) {return *reinterpret_cast<int *>(t);}
463 EOT
464 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
465 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
466 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
467
468
469 ### check if varsize array on stack ####
470 cat > $t <<EOT
471 #include <stdio.h>
472 void foo()
473 {
474   int size=10;
475   char arr[size];
476 }
477
478 EOT
479 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
480 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
481
482
483 #### check if templated members work ####
484 cat > $t <<EOT
485 typedef void (*func_t)(void);
486 class foo_foo {
487 protected:
488         int len;
489 };
490 class foo: public foo_foo {
491 public:
492         template<func_t f> //Templated member function
493         void memb(void) {f(); len++;}
494 };
495 inline void fn() {}
496 void myfunc()
497 {
498   foo x;
499   x.template memb<fn>();
500 }
501 EOT
502 test_cxx "whether templated member functions work" "ok" "no" ""
503 AC_DEFINE_UNQUOTED(CMK_TEMPLATE_MEMBERS_BROKEN, $fail, [whether templated member functions work])
504
505 ##### check if the stl headers use .h #####
506 cat > $t <<EOT
507 #include <iostream>
508 void foo(void) { std::cout<<"Hello, world"<<std::endl; }
509 EOT
510 test_cxx "whether including STL <foo> works" "ok" "no" ""
511 AC_DEFINE_UNQUOTED(CMK_STL_USE_DOT_H, $fail, [including STL <foo> does not works])
512 AC_DEFINE_UNQUOTED(CMK_STL_DONT_USE_DOT_H, $pass, [including STL <foo> works])
513
514 #### check if std::vector works ######
515 cat > $t <<EOT
516 #include <vector>
517
518 int foo(void) {
519   std::vector<int> v;      
520   v.push_back(2); v.push_back(3);
521   std::vector<int>::iterator it=v.begin();
522   it++;
523   return *it;
524 }
525 EOT
526 test_cxx "whether the std:: names for STL work" "ok" "no" ""
527 AC_DEFINE_UNQUOTED(CMK_USE_STL, $pass, [whether the std:: names for STL work])
528
529 #### check if namespaces can be defined #####
530 cat > $t <<EOT
531 namespace foo {
532         int x;
533 };
534 EOT
535 test_cxx "whether namespaces work" "ok" "no" ""
536 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
537
538
539 #### check if typeinfo exists and works #####
540 cat > $t <<EOT
541 #include <typeinfo>
542 const char *foo(void) {
543         int x;
544         return typeid(x).name();
545 }
546 EOT
547 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
548 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
549
550 #### check if iterator_traits is defined #####
551 cat > $t <<EOT
552 #include <iterator>
553
554 template <typename T> // T models Input Iterator
555 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
556 {
557       typename std::iterator_traits<T>::value_type result = 0;
558       while(first != last)
559             result += *first++;
560       return result;
561 }
562 EOT
563 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
564 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
565
566 #### check if std::distance is defined #####
567 cat > $t <<EOT
568 #include <vector>
569 #include <iterator>
570
571 int foo()
572 {
573   std::vector<int> tree;
574   return std::distance(tree.begin(), tree.end());
575 }
576 EOT
577 test_cxx "whether std::distance is defined" "ok" "no" ""
578 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
579
580
581 #### test if we can have multiple delete like this ####
582 cat > $t <<EOT
583 class foo {
584 public:
585   void operator delete(void*p){};
586   void operator delete(void*p,int*){};
587 };
588 EOT
589 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
590 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
591
592
593 #### test if we can use gcc x86 assembly like this ####
594 cat > $t <<EOT
595 double foo(void)
596 {
597   unsigned long long int v;
598   int *lo=0+(int *)&v;
599   int *hi=1+(int *)&v;
600   __asm__ __volatile__(
601       "rdtsc; movl %%edx,%0; movl %%eax,%1"
602       : /* output  */ "=m" (*hi), "=m" (*lo)
603       : /* input */
604       : /* trashes */ "%edx", "%eax"
605   );
606   return v;
607 }
608 EOT
609 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
610 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
611
612 #### test if we can use gcc x86 assembly like this ####
613 if test $strictpass = 1
614 then
615 cat > $t <<EOT
616 int foo(void)
617 {
618   int x;
619   asm("lock incl %0" :: "m" (x));
620   asm("lock decl %0" :: "m" (x));
621   return x;
622 }
623 EOT
624 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
625 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
626 fi
627
628 #### test if we can use gcc IA64 assembly like this ####
629 cat > $t <<EOT
630 double foo(void)
631 {
632         unsigned long long int x;
633         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
634         return x;
635 }
636 EOT
637 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
638 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
639
640
641 #### test if we can use PPC assembly like this ####
642 cat > $t <<EOT
643 double foo(void)
644 {
645         unsigned long long int x;
646         asm volatile("eieio" ::: "memory");
647         return x;
648 }
649 EOT
650 test_cxx "whether PPC assembly works" "yes" "no" ""
651 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
652
653
654
655 #### test if we can use __thread ####
656 cat > $t <<EOT
657 __thread unsigned long long int x;
658 static __thread  int y;
659 void foo(void)
660 {
661         x = 1;
662         y = 1;
663 }
664 EOT
665 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
666 AC_DEFINE_UNQUOTED(CMK_TLS_THREAD, $strictpass, [Allows __thread.])
667
668 #### test if we can build MPI ####
669 cat > $t <<EOT
670 #include "mpi.h"
671 int main(int argc, char **argv)
672 {
673   MPI_Init(&argc, &argv);
674 }
675 EOT
676 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
677 test_cxx "whether build on MPI" "yes" "no" ""
678 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
679 BUILD_MPI=$strictpass
680
681 if test $strictpass -eq 1
682 then
683 cat > $t <<EOT
684 #include "mpi.h"
685 int main(int argc, char **argv)
686 {
687   int thread_level, provided;
688   thread_level = MPI_THREAD_FUNNELED;
689   MPI_Init_thread(&argc, &argv, thread_level, &provided);
690 }
691 EOT
692 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
693 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
694 fi
695 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
696
697
698 ################### Syscalls and Libraries ###################
699
700 #### test for log2 ###
701 cat > $t <<EOT
702 #include <math.h>
703 int main() {
704   int i = log2(10);
705   return 0;
706 }
707 EOT
708 test_link "whether has log2" "yes" "no" ""
709 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
710
711 #### test for sqrtf ###
712 cat > $t <<EOT
713 #include <math.h>
714 int main() {
715   float i = sqrtf((float)10.0);
716   return 0;
717 }
718 EOT
719 test_link "whether has sqrtf" "yes" "no" ""
720 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
721
722 #### test for mkstemp ###
723 cat > $t <<EOT
724 #include <stdlib.h>
725 #include <string.h>
726 int main() {
727   char fname[[128]];
728   strcpy(fname, "/tmp/fdXXX.XXX");
729   mkstemp(fname);
730   return 0;
731 }
732 EOT
733 test_link "whether has mkstemp" "yes" "no" ""
734 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
735
736 #### test for system ###
737 cat > $t <<EOT
738 #include <stdlib.h>
739 int main() {
740   system("/bin/ls");
741   return 0;
742 }
743 EOT
744 test_link "whether has system" "yes" "no" ""
745 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
746
747 #### test for sbrk ###
748 cat > $t <<EOT
749 #include <unistd.h>
750 int main() {
751   void *ptr  = sbrk(0); 
752 }
753 EOT
754 test_link "whether has sbrk" "yes" "no" ""
755 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
756
757 #### test for mstats ###
758 cat > $t <<EOT
759 #include <malloc.h>
760 int main() {
761   struct mstats ms = mstats();
762 }
763 EOT
764 test_link "whether has mstats" "yes" "no" ""
765 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
766
767 #### test for mallinfo ###
768 cat > $t <<EOT
769 #include <malloc.h>
770 int main() {
771   struct mallinfo mi = mallinfo();
772 }
773 EOT
774 test_link "whether has mallinfo" "yes" "no" ""
775 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
776
777 #### test for popen ###
778 cat > $t <<EOT
779 #include <stdio.h>
780 int main() {
781   FILE *p = popen("/bin/ps", "r");
782   pclose(p);
783 }
784 EOT
785 test_link "whether has popen" "yes" "no" ""
786 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
787
788 #### test for poll ###
789 cat > $t <<EOT
790 #include <poll.h>
791 void foo(void) { 
792   struct pollfd pos[[3]];
793   poll(pos, 1, 1);
794 }
795 EOT
796 test_cxx "whether poll() syscall exists" "yes" "no" ""
797 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll() syscall exists])
798
799 #### check if getpid exists ####
800 cat > $t <<EOT
801 #include <sys/types.h>
802 #include <unistd.h>
803
804 void foo(void *a) {
805     pid_t = getpid();
806 }
807 EOT
808 test_cc "whether getpid() exists" "yes" "no" ""
809 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid() exists])
810
811 #### test for setpriority ###
812 cat > $t <<EOT
813 #include <sys/time.h>
814 #include <sys/resource.h>
815 void foo(void) { 
816   setpriority(PRIO_PROCESS, 0, 0);
817 }
818 EOT
819 test_cxx "whether setpriority() exists" "yes" "no" ""
820 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority() exists])
821
822 #### test for system ###
823 cat > $t <<EOT
824 #include "ckdll_system.C"
825 EOT
826 test_cxx "whether to use signal-safe system() " "yes" "no" ""
827 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
828
829 ### test sched_setaffinity ####
830 cat > $tc <<EOT
831 #include <stdlib.h>
832 #include <stdio.h>
833 #include <unistd.h>
834
835 #define _GNU_SOURCE
836 #include <sched.h>
837 long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
838 long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
839
840 int main()
841 {
842   unsigned long mask = 0xffffffff;
843   unsigned int len = sizeof(mask);
844
845   if (sched_setaffinity(0, len, &mask) < 0) {
846     return -1;
847   }
848   return 0;
849 }
850 EOT
851 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
852 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
853
854 ### test pthread_setaffinity_np ####
855 cat > $tc <<EOT
856 #include <stdlib.h>
857 #include <stdio.h>
858 #include <unistd.h>
859 #include <pthread.h>
860
861 int main()
862 {
863   unsigned long mask = 0xffffffff;
864   unsigned int len = sizeof(mask);
865
866   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
867     return -1;
868   }
869   return 0;
870 }
871 EOT
872 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
873 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
874
875 #### check bindprocessors on AIX ####
876 cat > $tc <<EOT
877 #include <stdlib.h>
878 #include <stdio.h>
879 #include <unistd.h>
880
881 #include <sys/processor.h>
882
883 int main()
884 {
885   int retValue = 0;
886   int pid;
887   pid = getpid();
888   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
889   return 0;
890 }
891 EOT
892 test_linkc "whether bindprocessor call exists" "yes" "no" ""
893 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
894 exists])
895
896
897 #### check if dlopen works ####
898 skip_dl=0
899 # for bproc, ignore -ldl
900 test -n "$CMK_BPROC" && skip_dl=1
901 test -n "$CMK_NO_DL" && skip_dl=1
902 dl_opt='-ldl'
903 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
904 case "$CMK_CXX" in
905 pgCC*) dl_opt='-Wl,-ldl' ;;
906 esac
907
908 if test $skip_dl -eq 0 
909 then
910
911 cat > $t <<EOT
912 #include "ckdll_dlopen.C"
913 int main() {
914         CkDll dll("foo.so");
915         return 0;
916 }
917 EOT
918 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
919 noldl=$pass
920 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
921 if test $pass -eq 1
922 then 
923 #dlopen requires -ldl: add it to our link line
924         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
925 fi
926
927 if test $pass -eq 1 -o $noldl -eq 1
928 then
929 # One version or another of dlopen worked: compile it in
930         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
931 fi
932
933 ### test gethostname ####
934 cat > $tc <<EOT
935 #include <stdlib.h>
936 #include <stdio.h>
937 #include <unistd.h>
938
939 int main()
940 {
941   char hostname[[1000]];
942   gethostname(hostname, 999);
943   return 0;
944 }
945 EOT
946 test_linkc "whether gethostname call exists" "yes" "no" ""
947 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
948
949 #### check if getProcAddress works ####
950 cat > $t <<EOT
951 #include "ckdll_win32.C"
952 EOT
953 test_cxx "whether getProcAddress works" "yes" "no" ""
954 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
955
956 fi    # end of skip_dl
957
958 #### check if socklen_t exists ####
959 cat > $t <<EOT
960 #include <sys/types.h>
961 #include <sys/socket.h>
962
963 void foo(void) {
964         int i;
965         socklen_t s=sizeof(i);
966 }
967 EOT
968 test_cxx "whether has socklen_t" "yes" "no" ""
969 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
970
971 #### check if mmap exists ####
972 cat > $t <<EOT
973 #include <sys/types.h>
974 #include <sys/mman.h>
975
976 void *foo(void *a,int l,int fd) {
977         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
978                  MAP_FIXED+MAP_PRIVATE,fd,0);
979 }
980 EOT
981 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
982 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
983
984 #### check if mmap accepts MAP_ANON ####
985 cat > $t <<EOT
986 #include <sys/types.h>
987 #include <sys/mman.h>
988
989 void *foo(void *a,int l) {
990         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
991                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
992 }
993 EOT
994 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
995 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
996
997 #### check if mmap accepts MAP_NORESERVE ####
998 cat > $t <<EOT
999 #include <sys/types.h>
1000 #include <sys/mman.h>
1001
1002 void *foo(void *a,int l) {
1003         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1004                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1005 }
1006 EOT
1007 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1008 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1009
1010 #### check if get_myaddress exists ####
1011 cat > $t <<EOT
1012 #include <rpc/rpc.h>
1013
1014 void foo(void *a) {
1015     get_myaddress((struct sockaddr_in*)a);
1016 }
1017 EOT
1018 test_cxx "whether get_myaddress() exists" "yes" "no" ""
1019 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether get_myaddress() exists])
1020
1021 #### check if glibc backtrace exists ####
1022 cat > $t <<EOT
1023 #include "cmibacktrace.c"
1024
1025 int main() {
1026         int nLevels=1;
1027         void *stack;
1028         CmiBacktraceRecord(&stack,0,&nLevels);
1029         return 0;
1030 }
1031 EOT
1032 TRACE_LINK_FLAG="-rdynamic"
1033 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1034 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1035
1036 if test $strictpass -eq 1
1037 then 
1038         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1039         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1040 fi
1041
1042 #### test sleep ####
1043 cat > $t <<EOT
1044 #include <unistd.h>
1045 int main() {
1046   sleep(1);
1047   return 0;
1048 }
1049 EOT
1050 test_cxx "whether has sleep " "yes" "no" ""
1051 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1052
1053
1054 #### test personality() and ADDR_NO_RANDOMIZE ####
1055 # Only works on modern Linux systems
1056 cat > $t <<EOT
1057 #include <sys/personality.h>
1058 int main() {
1059     int orig_persona = personality(0xffffffff);
1060     personality(orig_persona | ADDR_NO_RANDOMIZE);
1061     return 0;
1062 }
1063 EOT
1064 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1065 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1066
1067
1068 #### test if has zlib ####
1069 # bproc doesnot like -lz in any case
1070 if test -z "$CMK_BPROC"
1071 then
1072
1073 cat > $t <<EOT
1074 #include <zlib.h>
1075 int main() { 
1076   gzFile f = gzopen("/tmp/x","r");
1077   gzprintf(f, "test...\n");
1078   gzclose(f);
1079   return 0;
1080 }
1081 EOT
1082 test_link "whether has zlib" "yes" "no" "-lz"
1083 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1084 if test $pass -eq 1
1085 then 
1086         add_flag 'CMK_LIBZ="-lz"' "zlib"
1087 fi
1088
1089 fi
1090
1091 #### test if has elf.h ####
1092 cat > $t <<EOT
1093 #include <elf.h>
1094 typedef Elf32_Addr ELF_TYPE_Addr;
1095 int main() { 
1096 }
1097 EOT
1098 test_cxx "whether has elf.h " "yes" "no" ""
1099 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1100
1101 #### test if has Multiprocessing.h for apple ####
1102 cat > $t <<EOT
1103 #include <Carbon/Carbon.h>
1104 #include <Multiprocessing.h>
1105 int main() {
1106   int a = MPProcessorsScheduled();
1107 }
1108 EOT
1109 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1110 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1111
1112 #### test if "ntohl" is available ####
1113 cat > $t <<EOT
1114 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1115 #include <winsock.h>
1116 #else
1117 #include <netinet/in.h>
1118 #include <arpa/inet.h>
1119 #endif
1120
1121 int main() {
1122   int i = 100;
1123   i = ntohl(i);
1124   return 0;
1125 }
1126 EOT
1127 test_link "whether ntohl is available" "yes" "no" ""
1128 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1129
1130 ### test for libjpeg ####
1131 cat > $t <<EOT
1132 #include <stdio.h>
1133 #include <stdlib.h>
1134 #include "jpeglib.h"
1135
1136 int main()
1137 {
1138   struct jpeg_compress_struct cinfo;
1139   jpeg_create_compress(&cinfo);
1140   return 0;
1141 }
1142 EOT
1143 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1144 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1145 if test $pass -eq 1
1146 then
1147         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1148 fi
1149
1150 #### check if PAPI exists ####
1151 if test -n "$CMK_USE_PAPI"
1152 then
1153 cat > $t <<EOT
1154 #include <stdio.h>
1155 #include <papi.h>
1156                                                                                 
1157 int main() {
1158     int Events[[1]] = { PAPI_TOT_CYC };
1159     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
1160     return 0;
1161 }
1162 EOT
1163 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1164 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1165 if test $pass -eq 1
1166 then 
1167         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1168 fi
1169 fi
1170
1171 #### test if Python headers are installed ####
1172 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1173 cat > $t <<EOT
1174 #include "python${PYTHON_VERSION}/Python.h"
1175 #include "python${PYTHON_VERSION}/compile.h"
1176 #include "python${PYTHON_VERSION}/eval.h"
1177 #include "python${PYTHON_VERSION}/node.h"
1178
1179 int main() {
1180     Py_Initialize();
1181     PyEval_InitThreads();
1182     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1183     PyCodeObject *program = PyNode_Compile(programNode, "");
1184 }
1185 EOT
1186 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1187 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1188 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1189 if test $pass -eq 1
1190 then
1191         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1192 fi
1193
1194 #### test if it can build shared library ####
1195 cat > $t <<EOT
1196 #include "stdlib.h"
1197 extern int foo();
1198 int foo1() { 
1199   void * t= malloc(2);
1200   foo();
1201   return 0;
1202 }
1203 EOT
1204 test_linkso "whether can build shared library" "yes" "no" ""
1205 if test $pass -eq 0
1206 then 
1207         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1208 else
1209         BUILD_SHARED=1
1210         if test $BUILD_MPI -eq 1
1211         then
1212 cat > $t <<EOT
1213 #include "stdlib.h"
1214 #include "mpi.h"
1215 extern int foo();
1216 int foo(int argc, char ** argv) {
1217   void * t= malloc(2);
1218   foo();
1219   MPI_Init(&argc, &argv);
1220   return 0;
1221 }
1222 EOT
1223                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1224                 BUILD_SHARED=$pass
1225         fi
1226         if test $BUILD_SHARED -eq 1
1227         then
1228                 add_flag 'CMK_NO_BUILD_SHARED="false"' "build-shared"
1229         else
1230                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1231         fi
1232 fi
1233
1234 #### test the version number of bproc ####
1235 if test -n "$CMK_BPROC"
1236 then
1237 cat > $t <<EOT
1238 #include <stdio.h>
1239 #include <sys/bproc.h>
1240 int main()
1241 {
1242   struct bproc_version_t vers;
1243   bproc_version(&vers);
1244   printf("%s\n", vers.version_string);
1245 }
1246 EOT
1247 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1248 if test $pass -eq 1
1249 then 
1250 AC_MSG_CHECKING("bproc version")
1251 bproc_ver=`./testlink`
1252 if test x$bproc_ver = x
1253 then
1254 test_result 0 "bproc version" "ERROR" ""
1255 test_finish 1
1256 else
1257 test_result 0 "bproc version" "$bproc_ver" ""
1258 fi
1259 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1260 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1261 fi
1262 fi
1263
1264 #### test the if command sync exists ####
1265 AC_CHECK_PROG(SYNC, sync, sync )
1266 if test -n "$SYNC"
1267 then
1268 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1269 fi
1270
1271 ################## Fortran #########################
1272
1273 #echo "set F77 compiler as: $CMK_CF77"
1274 AC_MSG_CHECKING("F77 compiler as")
1275 AC_MSG_RESULT("$CMK_CF77")
1276
1277 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1278 ### test fortran 77 compiler ###
1279 cat > conftest.f <<EOF
1280       SUBROUTINE FOO_foo
1281       END
1282 EOF
1283 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1284 if test ! -r conftest.o
1285 then
1286   AC_MSG_RESULT("no")
1287 else
1288   AC_MSG_RESULT("yes")
1289 fi
1290
1291 ### test fortran 90 compiler ###
1292 #echo "set F90 compiler as: $CMK_CF90"
1293 AC_MSG_CHECKING("F90 compiler as")
1294 AC_MSG_RESULT("$CMK_CF90")
1295
1296 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1297 cat > conftest2.f90 <<EOF
1298       SUBROUTINE FOO_foo
1299       END
1300 EOF
1301 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1302 if test ! -r conftest2.o
1303 then
1304   AC_MSG_RESULT("no")
1305 else
1306   AC_MSG_RESULT("yes")
1307   mv -f conftest2.o conftest.o
1308   USE_FORTRAN90=1
1309 fi
1310
1311 ### check fortran name mangling
1312 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1313
1314 if test -r conftest.o
1315 then
1316   AC_CACHE_VAL(fortran_postfix,
1317
1318   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1319   if test "$NAME" != ""
1320   then
1321     fortran_postfix=TWOSCORE
1322     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1323   else
1324     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1325     if test "$NAME" != ""
1326     then
1327       fortran_postfix=ONESCORE
1328       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1329     else
1330       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1331       if test "$NAME" != ""
1332       then
1333         fortran_postfix=NOSCORE
1334         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1335       else
1336         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1337         if test "$NAME" != ""
1338         then
1339           fortran_postfix=ALLCAPS
1340           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1341         else
1342           echo "#################################################"
1343           echo "FORTRAN compiler generated name not supported yet"
1344           echo "#################################################"
1345         fi
1346       fi
1347     fi
1348   fi
1349   rm -f conftest.f conftest.o
1350   )
1351   AC_MSG_RESULT($fortran_postfix)
1352 else
1353   AC_MSG_RESULT("Fortran compiler not working")
1354 fi
1355
1356 ### check module name ###
1357
1358 if test "$USE_FORTRAN90" = 1
1359 then
1360   cat > conftest.f90 <<EOF
1361       MODULE testmod
1362         interface 
1363           function fpup_issizing(p)
1364           INTEGER :: p
1365           logical fpup_issizing
1366           end function
1367         end interface
1368       END MODULE
1369 EOF
1370   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1371   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1372   name=`ls TESTMOD.* 2>/dev/null`
1373   if test -n "$name"
1374   then
1375         AC_MSG_RESULT("yes")
1376         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1377   else
1378         AC_MSG_RESULT("no")
1379         name=`ls testmod.* 2>/dev/null`
1380   fi
1381   if test -n "$name"
1382   then
1383         AC_MSG_CHECKING(Fortran 90 mod name extension)
1384         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1385         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1386         AC_MSG_RESULT("$ext")
1387         /bin/rm -f $name
1388   fi
1389   /bin/rm -f conftest.f90
1390 fi
1391
1392 ### go get libpthread.a from charm website ###
1393 if test "$base_version" = "net-linux" || test "$base_version" = "mpi-linux"
1394 then
1395 case $version in
1396 *linux*smp*|*linux*vmi*)
1397   if test ! -r ../lib/libpthread.a
1398   then
1399     AC_CHECK_PROG(WGET, wget, wget )
1400     AC_CHECK_PROG(LYNX, lynx, lynx )
1401     AC_CHECK_PROG(TELNET, telnet, telnet )
1402     AC_CHECK_PROG(UUDECODE, uudecode, uudecode )
1403     
1404     CHARMIP='128.174.241.81'
1405 #    CHARMIP='charm.cs.uiuc.edu'
1406 #    VERSION=`nm /lib/libc.so.6 | grep "A GLIBC_" | tail -1 | sed -e "s/00000000 A GLIBC_//g"`
1407     AC_MSG_CHECKING(glibc version)
1408     get_glibc_version
1409     AC_MSG_RESULT($GLIBCVERSION)
1410     if test 1 = `expr $GLIBCVERSION \> 2.2.92` 
1411     then
1412       cat >> ./conv-mach-opt.h << EOT
1413 #undef CMK_LINUX_PTHREAD_HACK
1414 EOT
1415     else
1416       L="libpthread-$GLIBCVERSION.a"
1417       LSO="libpthread-$GLIBCVERSION.so"
1418       URL="http://${CHARMIP}/distrib/$L"
1419       URLSO="http://${CHARMIP}/distrib/$LSO"
1420       finish=0
1421       printf "getting $L from $URL ..."
1422       if test -n "$WGET"
1423       then
1424         printf "(wget) ..."
1425         $WGET $URL > /dev/null 2>&1  && mv $L ../lib && finish=1
1426         $WGET $URLSO > /dev/null 2>&1  && mv $LSO ../lib_so
1427       fi
1428       if test $finish = 0 && test -n "$LYNX"
1429       then
1430         printf "(lynx) ..."
1431         $LYNX -source $URL > $L 2>/dev/null 
1432         if file -L $L | grep 'archive' > /dev/null
1433         then
1434           mv $L ../lib && finish=1
1435         fi
1436         $LYNX -source $URLSO > $L 2>/dev/null 
1437       fi
1438       if test $finish = 0 && test -n "$TELNET" && test -n "$UUDECODE"
1439       then
1440         printf "(telnet) ..."
1441         cat > get_libpthread <<EOT
1442 #! /bin/sh
1443 echo "GET /distrib/libpthread-$GLIBCVERSION.uu 1.0"
1444 echo
1445 # exit normally when the telnet session closes.
1446 trap "exit 0" 13
1447 while : ; do
1448  echo
1449  sleep 1
1450 done
1451 EOT
1452         /bin/sh ./get_libpthread | ($TELNET $CHARMIP 80 > .uulib 2>/dev/null); $UUDECODE .uulib 2>/dev/null && rm -f .uulib && mv $L ../lib && finish=1
1453       fi
1454       ln -s $L ../lib/libpthread.a
1455       ln -s $LSO ../lib_so/libpthread.so
1456       if test $finish = 0 || test ! -r ../lib/libpthread.a
1457       then
1458         /bin/rm -f ../lib/libpthread.a
1459         echo "failed"
1460         echo "#####################################################################"
1461         echo "wget, lynx or telnet must be installed to get libpthread.a from charm website."
1462         echo "Alternately, your version of GLIBC ($GLIBCVERSION) is not yet supported--"
1463         echo " contact ppl@cs.uiuc.edu for assistance."
1464         echo "#####################################################################"
1465         exit 1
1466       else
1467         echo "done"
1468       fi
1469     fi
1470   fi
1471   ;;
1472 esac
1473 fi
1474
1475 AC_OUTPUT(
1476 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
1477
1478 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
1479 )