← Back to branch summary

~ubuntu-branches/ubuntu/saucy/strace/saucy

« back to all changes in this revision

Viewing changes to aclocal.m4

  • Committer: Bazaar Package Importer
  • Author(s): Anand Kumria
  • Date: 2001-10-01 14:22:25 UTC
  • Revision ID: james.westby@ubuntu.com-20011001142225-h6l10cregbilmpw5
Tags: 4.4-1.2
http://bugs.debian.org/109993
* NMU
* Quick one-liner to allow building on the ARM. Closes: #109993.
* Re-ran autoconf, hopefully I didn't break other arches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
484
dnl ### A macro to determine endianness of long long
 
485
AC_DEFUN(AC_LITTLE_ENDIAN_LONG_LONG,
 
486
[AC_MSG_CHECKING(for little endian long long)
 
487
AC_CACHE_VAL(ac_cv_have_little_endian_long_long,
 
488
[AC_TRY_RUN([
 
489
int main () {
 
490
        union {
 
491
                long long ll;
 
492
                long l [2];
 
493
        } u;
 
494
        u.ll = 0x12345678;
 
495
        if (u.l[0] == 0x12345678) 
 
496
                return 0;
 
497
        return 1;
 
498
}
 
499
],
 
500
ac_cv_have_little_endian_long_long=yes,
 
501
ac_cv_have_little_endian_long_long=no,
 
502
[# Should try to guess here
 
503
ac_cv_have_little_endian_long_long=no
 
504
])])
 
505
AC_MSG_RESULT($ac_cv_have_little_endian_long_long)
 
506
if test "$ac_cv_have_little_endian_long_long" = yes
 
507
then
 
508
        AC_DEFINE(HAVE_LITTLE_ENDIAN_LONG_LONG)
 
509
fi
 
510
])
 
511