granicus.if.org Git - strace/blob - aclocal.m4

   1 dnl ### A macro to find the include directory, useful for cross-compiling.
   2 AC_DEFUN(AC_INCLUDEDIR,
   3 [AC_REQUIRE([AC_PROG_AWK])dnl
   4 AC_SUBST(includedir)
   5 AC_MSG_CHECKING(for primary include directory)
   6 includedir=/usr/include
   7 if test -n "$GCC"
   8 then
   9         >conftest.c
  10         new_includedir=`
  11                 $CC -v -E conftest.c 2>&1 | $AWK '
  12                         /^End of search list/ { print last; exit }
  13                         { last = [$]1 }
  14                 '
  15         `
  16         rm -f conftest.c
  17         if test -n "$new_includedir" && test -d "$new_includedir"
  18         then
  19                 includedir=$new_includedir
  20         fi
  21 fi
  22 AC_MSG_RESULT($includedir)
  23 ])
  24
  25 dnl ### A macro to automatically set different CC and HOSTCC if using gcc.
  26 define(AC_PROG_HOSTCC,
  27 [AC_SUBST(HOSTCC)dnl
  28 if test -z "$HOSTCC"
  29 then
  30         HOSTCC="$CC"
  31         if test -n "$GCC"
  32         then
  33                 # Find out if gcc groks our host.
  34                 worked=
  35                 last=
  36                 for i in $1
  37                 do
  38                         test "x$i" = "x$last" && continue
  39                         last="$i"
  40                         CC="$HOSTCC -b $i"
  41                         AC_MSG_CHECKING([for working $CC])
  42                         AC_TRY_LINK(,,
  43                                 worked=1
  44                                 break
  45                         )
  46                         AC_MSG_RESULT(no)
  47                 done
  48                 if test -z "$worked"
  49                 then
  50                         CC="$HOSTCC"
  51                 else
  52                         AC_MSG_RESULT(yes)
  53                 fi
  54         fi
  55 fi
  56 ])
  57
  58 dnl ### A macro to set gcc warning flags.
  59 define(AC_WARNFLAGS,
  60 [AC_SUBST(WARNFLAGS)
  61 if test -z "$WARNFLAGS"
  62 then
  63         if test -n "$GCC"
  64         then
  65                 # If we're using gcc we want warning flags.
  66                 WARNFLAGS=-Wall
  67         fi
  68 fi
  69 ])
  70
  71 dnl ### A macro to determine if we have a "MP" type procfs
  72 AC_DEFUN(AC_MP_PROCFS,
  73 [AC_MSG_CHECKING(for MP procfs)
  74 AC_CACHE_VAL(ac_cv_mp_procfs,
  75 [AC_TRY_RUN([
  76 #include <stdio.h>
  77 #include <signal.h>
  78 #include <sys/procfs.h>
  79
  80 main()
  81 {
  82         int pid;
  83         char proc[32];
  84         FILE *ctl;
  85         FILE *status;
  86         int cmd;
  87         struct pstatus pstatus;
  88
  89         if ((pid = fork()) == 0) {
  90                 pause();
  91                 exit(0);
  92         }
  93         sprintf(proc, "/proc/%d/ctl", pid);
  94         if ((ctl = fopen(proc, "w")) == NULL)
  95                 goto fail;
  96         sprintf(proc, "/proc/%d/status", pid);
  97         if ((status = fopen (proc, "r")) == NULL)
  98                 goto fail;
  99         cmd = PCSTOP;
 100         if (write (fileno (ctl), &cmd, sizeof cmd) < 0)
 101                 goto fail;
 102         if (read (fileno (status), &pstatus, sizeof pstatus) < 0)
 103                 goto fail;
 104         kill(pid, SIGKILL);
 105         exit(0);
 106 fail:
 107         kill(pid, SIGKILL);
 108         exit(1);
 109 }
 110 ],
 111 ac_cv_mp_procfs=yes,
 112 ac_cv_mp_procfs=no,
 113 [
 114 # Guess or punt.
 115 case "$host_os" in
 116 svr4.2*|svr5*)
 117         ac_cv_mp_procfs=yes
 118         ;;
 119 *)
 120         ac_cv_mp_procfs=no
 121         ;;
 122 esac
 123 ])])
 124 AC_MSG_RESULT($ac_cv_mp_procfs)
 125 if test "$ac_cv_mp_procfs" = yes
 126 then
 127         AC_DEFINE(HAVE_MP_PROCFS)
 128 fi
 129 ])
 130
 131 dnl ### A macro to determine if procfs is pollable.
 132 AC_DEFUN(AC_POLLABLE_PROCFS,
 133 [AC_MSG_CHECKING(for pollable procfs)
 134 AC_CACHE_VAL(ac_cv_pollable_procfs,
 135 [AC_TRY_RUN([
 136 #include <stdio.h>
 137 #include <signal.h>
 138 #include <sys/procfs.h>
 139 #include <sys/stropts.h>
 140 #include <poll.h>
 141
 142 #ifdef HAVE_MP_PROCFS
 143 #define PIOCSTOP        PCSTOP
 144 #define POLLWANT        POLLWRNORM
 145 #define PROC            "/proc/%d/ctl"
 146 #define PROC_MODE       "w"
 147 int IOCTL (int fd, int cmd, int arg) {
 148         return write (fd, &cmd, sizeof cmd);
 149 }
 150 #else
 151 #define POLLWANT        POLLPRI
 152 #define PROC            "/proc/%d"
 153 #define PROC_MODE       "r+"
 154 #define IOCTL           ioctl
 155 #endif
 156
 157 main()
 158 {
 159         int pid;
 160         char proc[32];
 161         FILE *pfp;
 162         struct pollfd pfd;
 163
 164         if ((pid = fork()) == 0) {
 165                 pause();
 166                 exit(0);
 167         }
 168         sprintf(proc, PROC, pid);
 169         if ((pfp = fopen(proc, PROC_MODE)) == NULL)
 170                 goto fail;
 171         if (IOCTL(fileno(pfp), PIOCSTOP, NULL) < 0)
 172                 goto fail;
 173         pfd.fd = fileno(pfp);
 174         pfd.events = POLLWANT;
 175         if (poll(&pfd, 1, 0) < 0)
 176                 goto fail;
 177         if (!(pfd.revents & POLLWANT))
 178                 goto fail;
 179         kill(pid, SIGKILL);
 180         exit(0);
 181 fail:
 182         kill(pid, SIGKILL);
 183         exit(1);
 184 }
 185 ],
 186 ac_cv_pollable_procfs=yes,
 187 ac_cv_pollable_procfs=no,
 188 [
 189 # Guess or punt.
 190 case "$host_os" in
 191 solaris2*|irix5*|svr4.2uw*|svr5*)
 192         ac_cv_pollable_procfs=yes
 193         ;;
 194 *)
 195         ac_cv_pollable_procfs=no
 196         ;;
 197 esac
 198 ])])
 199 AC_MSG_RESULT($ac_cv_pollable_procfs)
 200 if test "$ac_cv_pollable_procfs" = yes
 201 then
 202         AC_DEFINE(HAVE_POLLABLE_PROCFS)
 203 fi
 204 ])
 205
 206 dnl ### A macro to determine if the prstatus structure has a pr_syscall member.
 207 AC_DEFUN(AC_STRUCT_PR_SYSCALL,
 208 [AC_MSG_CHECKING(for pr_syscall in struct prstatus)
 209 AC_CACHE_VAL(ac_cv_struct_pr_syscall,
 210 [AC_TRY_COMPILE([#include <sys/procfs.h>],
 211 [#ifdef HAVE_MP_PROCFS
 212 pstatus_t s;
 213 s.pr_lwp.pr_syscall
 214 #else
 215 prstatus_t s;
 216 s.pr_syscall
 217 #endif],
 218 ac_cv_struct_pr_syscall=yes,
 219 ac_cv_struct_pr_syscall=no)])
 220 AC_MSG_RESULT($ac_cv_struct_pr_syscall)
 221 if test "$ac_cv_struct_pr_syscall" = yes
 222 then
 223         AC_DEFINE(HAVE_PR_SYSCALL)
 224 fi
 225 ])
 226
 227 dnl ### A macro to detect the presence of the sig_atomic_t in signal.h
 228 AC_DEFUN(AC_SIG_ATOMIC_T,
 229 [AC_MSG_CHECKING(for sig_atomic_t in signal.h)
 230 AC_CACHE_VAL(ac_cv_sig_atomic_t,
 231 [AC_TRY_COMPILE([#include <signal.h>],
 232 [sig_atomic_t x;],
 233 ac_cv_sig_atomic_t=yes,
 234 ac_cv_sig_atomic_t=no)])
 235 AC_MSG_RESULT($ac_cv_sig_atomic_t)
 236 if test "$ac_cv_sig_atomic_t" = yes
 237 then
 238         AC_DEFINE(HAVE_SIG_ATOMIC_T)
 239 fi
 240 ])
 241
 242 dnl ### A macro to determine if sys_errlist is declared.
 243 AC_DEFUN(AC_DECL_SYS_ERRLIST,
 244 [AC_MSG_CHECKING([for sys_errlist declaration])
 245 AC_CACHE_VAL(ac_cv_decl_sys_errlist,
 246 [AC_TRY_COMPILE([#include <sys/types.h>
 247 #include <errno.h>
 248 #include <stdio.h>
 249 /* Somebody might declare sys_errlist in unistd.h.  */
 250 #ifdef HAVE_UNISTD_H
 251 #include <unistd.h>
 252 #endif], [char *msg = *(sys_errlist + 1);],
 253   ac_cv_decl_sys_errlist=yes, ac_cv_decl_sys_errlist=no)])dnl
 254 AC_MSG_RESULT($ac_cv_decl_sys_errlist)
 255 if test $ac_cv_decl_sys_errlist = yes; then
 256   AC_DEFINE(SYS_ERRLIST_DECLARED)
 257 fi
 258 ])
 259
 260 dnl ### A macro to determine if _sys_siglist is declared.
 261 AC_DEFUN(AC_DECL__SYS_SIGLIST,
 262 [AC_MSG_CHECKING([for _sys_siglist declaration])
 263 AC_CACHE_VAL(ac_cv_decl__sys_siglist,
 264 [AC_TRY_COMPILE([#include <sys/types.h>
 265 #include <signal.h>
 266 /* Somebody might declare _sys_siglist in unistd.h.  */
 267 #ifdef HAVE_UNISTD_H
 268 #include <unistd.h>
 269 #endif], [char *msg = *(_sys_siglist + 1);],
 270   ac_cv_decl__sys_siglist=yes, ac_cv_decl__sys_siglist=no)])dnl
 271 AC_MSG_RESULT($ac_cv_decl__sys_siglist)
 272 if test $ac_cv_decl__sys_siglist = yes; then
 273   AC_DEFINE(SYS_SIGLIST_DECLARED)
 274 fi
 275 ])
 276
 277 dnl ### A macro to determine if the msghdr structure has a msg_control member.
 278 AC_DEFUN(AC_STRUCT_MSG_CONTROL,
 279 [AC_MSG_CHECKING(for msg_control in struct msghdr)
 280 AC_CACHE_VAL(ac_cv_struct_msg_control,
 281 [AC_TRY_COMPILE([#include <sys/types.h>
 282 #include <sys/socket.h>],
 283 [#undef msg_control
 284 struct msghdr m; m.msg_control;],
 285 ac_cv_struct_msg_control=yes,
 286 ac_cv_struct_msg_control=no)])
 287 AC_MSG_RESULT($ac_cv_struct_msg_control)
 288 if test "$ac_cv_struct_msg_control" = yes
 289 then
 290         AC_DEFINE(HAVE_MSG_CONTROL)
 291 fi
 292 ])
 293
 294 dnl ### A macro to determine whether stat64 is defined.
 295 AC_DEFUN(AC_STAT64,
 296 [AC_MSG_CHECKING(for stat64 in (asm|sys)/stat.h)
 297 AC_CACHE_VAL(ac_cv_type_stat64,
 298 [AC_TRY_COMPILE([#ifdef linux
 299 #include <asm/stat.h>
 300 #else
 301 #include <sys/stat.h>
 302 #endif],
 303 [struct stat64 st;],
 304 ac_cv_type_stat64=yes,
 305 ac_cv_type_stat64=no)])
 306 AC_MSG_RESULT($ac_cv_type_stat64)
 307 if test "$ac_cv_type_stat64" = yes
 308 then
 309         AC_DEFINE(HAVE_STAT64)
 310 fi
 311 ])
 312
 313 dnl ### A macro to determine whether we have long long
 314 AC_DEFUN(AC_LONG_LONG,
 315 [AC_MSG_CHECKING(for long long)
 316 AC_CACHE_VAL(ac_cv_type_long_long,
 317 [AC_TRY_COMPILE([],
 318 [long long x = 20;],
 319 ac_cv_type_long_long=yes,
 320 ac_cv_type_long_long=no)])
 321 AC_MSG_RESULT($ac_cv_type_long_long)
 322 if test "$ac_cv_type_long_long" = yes
 323 then
 324         AC_DEFINE(HAVE_LONG_LONG)
 325 fi
 326 ])
 327
 328 dnl ### A macro to determine if off_t is a long long
 329 AC_DEFUN(AC_OFF_T_IS_LONG_LONG,
 330 [AC_MSG_CHECKING(for long long off_t)
 331 AC_CACHE_VAL(ac_cv_have_long_long_off_t,
 332 [AC_TRY_RUN([#include <sys/types.h>
 333 main () {
 334         if (sizeof (off_t) == sizeof (long long) &&
 335             sizeof (off_t) > sizeof (long))
 336             return 0;
 337         return 1;
 338 }
 339 ],
 340 ac_cv_have_long_long_off_t=yes,
 341 ac_cv_have_long_long_off_t=no,
 342 [# Should try to guess here
 343 ac_cv_have_long_long_off_t=no
 344 ])])
 345 AC_MSG_RESULT($ac_cv_have_long_long_off_t)
 346 if test "$ac_cv_have_long_long_off_t" = yes
 347 then
 348         AC_DEFINE(HAVE_LONG_LONG_OFF_T)
 349 fi
 350 ])
 351
 352 dnl ### A macro to determine if rlim_t is a long long
 353 AC_DEFUN(AC_RLIM_T_IS_LONG_LONG,
 354 [AC_MSG_CHECKING(for long long rlim_t)
 355 AC_CACHE_VAL(ac_cv_have_long_long_rlim_t,
 356 [AC_TRY_RUN([#include <sys/types.h>
 357 #include <sys/time.h>
 358 #include <sys/resource.h>
 359 main () {
 360         if (sizeof (rlim_t) == sizeof (long long) &&
 361             sizeof (rlim_t) > sizeof (long))
 362             return 0;
 363         return 1;
 364 }
 365 ],
 366 ac_cv_have_long_long_rlim_t=yes,
 367 ac_cv_have_long_long_rlim_t=no,
 368 [# Should try to guess here
 369 ac_cv_have_long_long_rlim_t=no
 370 ])])
 371 AC_MSG_RESULT($ac_cv_have_long_long_rlim_t)
 372 if test "$ac_cv_have_long_long_rlim_t" = yes
 373 then
 374         AC_DEFINE(HAVE_LONG_LONG_RLIM_T)
 375 fi
 376 ])
 377
 378 dnl ### A macro to determine whether sin6_scope_id is available.
 379 AC_DEFUN(AC_SIN6_SCOPE_ID,
 380 [AC_MSG_CHECKING(for sin6_scope_id in sockaddr_in6)
 381 AC_CACHE_VAL(ac_cv_have_sin6_scope_id,
 382 [AC_TRY_COMPILE([#include <netinet/in.h>],
 383 [ struct sockaddr_in6 s; s.sin6_scope_id = 0; ],
 384 ac_cv_have_sin6_scope_id=yes,
 385 ac_cv_have_sin6_scope_id=no)])
 386 AC_MSG_RESULT($ac_cv_have_sin6_scope_id)
 387 if test "$ac_cv_have_sin6_scope_id" = "yes" ; then
 388        AC_DEFINE(HAVE_SIN6_SCOPE_ID)
 389 else
 390        AC_MSG_CHECKING(for sin6_scope_id in linux sockaddr_in6)
 391        AC_CACHE_VAL(ac_cv_have_sin6_scope_id_linux,
 392        [AC_TRY_COMPILE([#include <linux/in6.h>],
 393        [ struct sockaddr_in6 s; s.sin6_scope_id = 0; ],
 394        ac_cv_have_sin6_scope_id_linux=yes,
 395        ac_cv_have_sin6_scope_id_linux=no)])
 396        AC_MSG_RESULT($ac_cv_have_sin6_scope_id_linux)
 397        if test "$ac_cv_have_sin6_scope_id_linux" = "yes" ; then
 398                AC_DEFINE(HAVE_SIN6_SCOPE_ID)
 399                AC_DEFINE(HAVE_SIN6_SCOPE_ID_LINUX)
 400        fi
 401 fi
 402 ])
 403
 404 dnl ### A macro to check for st_flags in struct stat
 405 AC_DEFUN(AC_ST_FLAGS,
 406 [AC_MSG_CHECKING(for st_flags in struct stat)
 407 AC_CACHE_VAL(ac_cv_have_st_flags,
 408 [AC_TRY_COMPILE([#include <sys/stat.h>],
 409 [struct stat buf;
 410 buf.st_flags = 0;],
 411 ac_cv_have_st_flags=yes,
 412 ac_cv_have_st_flags=no)])
 413 AC_MSG_RESULT($ac_cv_have_st_flags)
 414 if test "$ac_cv_have_st_flags" = yes
 415 then
 416         AC_DEFINE(HAVE_ST_FLAGS)
 417 fi
 418 ])
 419
 420 dnl ### A macro to check for st_aclcnt in struct stat
 421 AC_DEFUN(AC_ST_ACLCNT,
 422 [AC_MSG_CHECKING(for st_aclcnt in struct stat)
 423 AC_CACHE_VAL(ac_cv_have_st_aclcnt,
 424 [AC_TRY_COMPILE([#include <sys/stat.h>],
 425 [struct stat buf;
 426 buf.st_aclcnt = 0;],
 427 ac_cv_have_st_aclcnt=yes,
 428 ac_cv_have_st_aclcnt=no)])
 429 AC_MSG_RESULT($ac_cv_have_st_aclcnt)
 430 if test "$ac_cv_have_st_aclcnt" = yes
 431 then
 432         AC_DEFINE(HAVE_ST_ACLCNT)
 433 fi
 434 ])
 435
 436 dnl ### A macro to check for st_level in struct stat
 437 AC_DEFUN(AC_ST_LEVEL,
 438 [AC_MSG_CHECKING(for st_level in struct stat)
 439 AC_CACHE_VAL(ac_cv_have_st_level,
 440 [AC_TRY_COMPILE([#include <sys/stat.h>],
 441 [struct stat buf;
 442 buf.st_level = 0;],
 443 ac_cv_have_st_level=yes,
 444 ac_cv_have_st_level=no)])
 445 AC_MSG_RESULT($ac_cv_have_st_level)
 446 if test "$ac_cv_have_st_level" = yes
 447 then
 448         AC_DEFINE(HAVE_ST_LEVEL)
 449 fi
 450 ])
 451
 452 dnl ### A macro to check for st_fstype in struct stat
 453 AC_DEFUN(AC_ST_FSTYPE,
 454 [AC_MSG_CHECKING(for st_fstype in struct stat)
 455 AC_CACHE_VAL(ac_cv_have_st_fstype,
 456 [AC_TRY_COMPILE([#include <sys/stat.h>],
 457 [struct stat buf;
 458 buf.st_fstype[0] = 0;],
 459 ac_cv_have_st_fstype=yes,
 460 ac_cv_have_st_fstype=no)])
 461 AC_MSG_RESULT($ac_cv_have_st_fstype)
 462 if test "$ac_cv_have_st_fstype" = yes
 463 then
 464         AC_DEFINE(HAVE_ST_FSTYPE)
 465 fi
 466 ])
 467
 468 dnl ### A macro to check for st_gen in struct stat
 469 AC_DEFUN(AC_ST_GEN,
 470 [AC_MSG_CHECKING(for st_gen in struct stat)
 471 AC_CACHE_VAL(ac_cv_have_st_gen,
 472 [AC_TRY_COMPILE([#include <sys/stat.h>],
 473 [struct stat buf;
 474 buf.st_gen = 0;],
 475 ac_cv_have_st_gen=yes,
 476 ac_cv_have_st_gen=no)])
 477 AC_MSG_RESULT($ac_cv_have_st_gen)
 478 if test "$ac_cv_have_st_gen" = yes
 479 then
 480         AC_DEFINE(HAVE_ST_GEN)
 481 fi
 482 ])
 483