• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1dnl AC_NEED_BYTEORDER_H ( HEADER-TO-GENERATE )
2dnl Copyright 2001-2002 by Dan Fandrich <dan@coneharvesters.com>
3dnl This file may be copied and used freely without restrictions.  No warranty
4dnl is expressed or implied.
5dnl
6dnl Create a header file that guarantees that byte swapping macros of the
7dnl ntohl variety as well as the extended types included in OpenBSD and
8dnl NetBSD such as le32toh are defined.  If possible, the standard ntohl
9dnl are overloaded as they are optimized for the given platform, but when
10dnl this is not possible (e.g. on a big-endian machine) they are defined
11dnl in this file.
12
13dnl Look for a symbol in a header file
14dnl AC_HAVE_SYMBOL ( IDENTIFIER, HEADER-FILE, ACTION-IF-FOUND, ACTION-IF-NOT-FOUND )
15AC_DEFUN([AC_HAVE_SYMBOL],
16[
17AC_MSG_CHECKING(for $1 in $2)
18AC_EGREP_CPP([symbol is present|\<$1\>],[
19#include <$2>
20#ifdef $1
21 	symbol is present
22#endif
23	],
24[AC_MSG_RESULT(yes)
25$3
26],
27[AC_MSG_RESULT(no)
28$4
29])])
30
31
32dnl Create a header file that defines extended byte swapping macros
33AC_DEFUN([AC_NEED_BYTEORDER_H],
34[
35ac_dir=`AS_DIRNAME(["$1"])`
36if test "$ac_dir" != "$1" && test "$ac_dir" != .; then
37  # The file is in a subdirectory.
38  test ! -d "$ac_dir" && (AS_MKDIR_P(["$ac_dir"]))
39fi
40
41# We're only interested in the target CPU, but it's not always set
42effective_target="$target"
43if test "x$effective_target" = xNONE -o "x$effective_target" = x ; then
44	effective_target="$host"
45fi
46AC_SUBST(effective_target)
47
48cat > "$1" << EOF
49/* This file is generated automatically by configure */
50/* It is valid only for the system type ${effective_target} */
51
52#ifndef __BYTEORDER_H
53#define __BYTEORDER_H
54
55EOF
56
57dnl First, do an endian check
58AC_C_BIGENDIAN
59
60dnl Look for NetBSD-style extended byte swapping macros
61AC_HAVE_SYMBOL(le32toh,machine/endian.h,
62 [HAVE_LE32TOH=1
63 cat >> "$1" << EOF
64/* extended byte swapping macros are already available */
65#include <machine/endian.h>
66
67EOF],
68
69[
70
71dnl Look for standard byte swapping macros
72AC_HAVE_SYMBOL(ntohl,arpa/inet.h,
73 [cat >> "$1" << EOF
74/* ntohl and relatives live here */
75#include <arpa/inet.h>
76
77EOF],
78
79 [AC_HAVE_SYMBOL(ntohl,netinet/in.h,
80  [cat >> "$1" << EOF
81/* ntohl and relatives live here */
82#include <netinet/in.h>
83
84EOF],true)])
85])
86
87dnl Look for generic byte swapping macros
88
89dnl OpenBSD
90AC_HAVE_SYMBOL(swap32,machine/endian.h,
91 [cat >> "$1" << EOF
92/* swap32 and swap16 are defined in machine/endian.h */
93
94EOF],
95
96 [
97dnl Linux GLIBC
98  AC_HAVE_SYMBOL(bswap_32,byteswap.h,
99   [cat >> "$1" << EOF
100/* Define generic byte swapping functions */
101#include <byteswap.h>
102#define swap16(x) bswap_16(x)
103#define swap32(x) bswap_32(x)
104#define swap64(x) bswap_64(x)
105
106EOF],
107
108   [
109dnl NetBSD
110  	AC_HAVE_SYMBOL(bswap32,machine/endian.h,
111    dnl We're already including machine/endian.h if this test succeeds
112  	 [cat >> "$1" << EOF
113/* Define generic byte swapping functions */
114EOF
115	if test "$HAVE_LE32TOH" != "1"; then
116		echo '#include <machine/endian.h>'>> "$1"
117	fi
118cat >> "$1" << EOF
119#define swap16(x) bswap16(x)
120#define swap32(x) bswap32(x)
121#define swap64(x) bswap64(x)
122
123EOF],
124
125   [
126dnl FreeBSD
127  	AC_HAVE_SYMBOL(__byte_swap_long,sys/types.h,
128  	 [cat >> "$1" << EOF
129/* Define generic byte swapping functions */
130#include <sys/types.h>
131#define swap16(x) __byte_swap_word(x)
132#define swap32(x) __byte_swap_long(x)
133/* No optimized 64 bit byte swapping macro is available */
134#define swap64(x) ((uint64_t)(((uint64_t)(x) << 56) & 0xff00000000000000ULL | \\
135			      ((uint64_t)(x) << 40) & 0x00ff000000000000ULL | \\
136			      ((uint64_t)(x) << 24) & 0x0000ff0000000000ULL | \\
137			      ((uint64_t)(x) << 8)  & 0x000000ff00000000ULL | \\
138			      ((x) >> 8)  & 0x00000000ff000000ULL | \\
139			      ((x) >> 24) & 0x0000000000ff0000ULL | \\
140			      ((x) >> 40) & 0x000000000000ff00ULL | \\
141			      ((x) >> 56) & 0x00000000000000ffULL))
142
143EOF],
144
145  	 [
146dnl OS X
147  	AC_HAVE_SYMBOL(NXSwapLong,machine/byte_order.h,
148  	 [cat >> "$1" << EOF
149/* Define generic byte swapping functions */
150#include <machine/byte_order.h>
151#define swap16(x) NXSwapShort(x)
152#define swap32(x) NXSwapLong(x)
153#define swap64(x) NXSwapLongLong(x)
154
155EOF],
156         [
157	if test $ac_cv_c_bigendian = yes; then
158		cat >> "$1" << EOF
159/* No other byte swapping functions are available on this big-endian system */
160#define swap16(x)	((uint16_t)(((x) << 8) | ((uint16_t)(x) >> 8)))
161#define swap32(x)	((uint32_t)(((uint32_t)(x) << 24) & 0xff000000UL | \\
162				    ((uint32_t)(x) << 8)  & 0x00ff0000UL | \\
163				    ((x) >> 8)  & 0x0000ff00UL | \\
164				    ((x) >> 24) & 0x000000ffUL))
165#define swap64(x) ((uint64_t)(((uint64_t)(x) << 56) & 0xff00000000000000ULL | \\
166			      ((uint64_t)(x) << 40) & 0x00ff000000000000ULL | \\
167			      ((uint64_t)(x) << 24) & 0x0000ff0000000000ULL | \\
168			      ((uint64_t)(x) << 8)  & 0x000000ff00000000ULL | \\
169			      ((x) >> 8)  & 0x00000000ff000000ULL | \\
170			      ((x) >> 24) & 0x0000000000ff0000ULL | \\
171			      ((x) >> 40) & 0x000000000000ff00ULL | \\
172			      ((x) >> 56) & 0x00000000000000ffULL))
173
174EOF
175	else
176 cat >> "$1" << EOF
177/* Use these as generic byteswapping macros on this little endian system */
178#define swap16(x)		ntohs(x)
179#define swap32(x)		ntohl(x)
180/* No optimized 64 bit byte swapping macro is available */
181#define swap64(x) ((uint64_t)(((uint64_t)(x) << 56) & 0xff00000000000000ULL | \\
182			      ((uint64_t)(x) << 40) & 0x00ff000000000000ULL | \\
183			      ((uint64_t)(x) << 24) & 0x0000ff0000000000ULL | \\
184			      ((uint64_t)(x) << 8)  & 0x000000ff00000000ULL | \\
185			      ((x) >> 8)  & 0x00000000ff000000ULL | \\
186			      ((x) >> 24) & 0x0000000000ff0000ULL | \\
187			      ((x) >> 40) & 0x000000000000ff00ULL | \\
188			      ((x) >> 56) & 0x00000000000000ffULL))
189
190EOF
191	fi
192])
193  	  ])
194    ])
195  ])
196])
197
198
199[
200if test "$HAVE_LE32TOH" != "1"; then
201 cat >> "$1" << EOF
202/* The byte swapping macros have the form: */
203/*   EENN[a]toh or htoEENN[a] where EE is be (big endian) or */
204/* le (little-endian), NN is 16 or 32 (number of bits) and a, */
205/* if present, indicates that the endian side is a pointer to an */
206/* array of uint8_t bytes instead of an integer of the specified length. */
207/* h refers to the host's ordering method. */
208
209/* So, to convert a 32-bit integer stored in a buffer in little-endian */
210/* format into a uint32_t usable on this machine, you could use: */
211/*   uint32_t value = le32atoh(&buf[3]); */
212/* To put that value back into the buffer, you could use: */
213/*   htole32a(&buf[3], value); */
214
215/* Define aliases for the standard byte swapping macros */
216/* Arguments to these macros must be properly aligned on natural word */
217/* boundaries in order to work properly on all architectures */
218#ifndef htobe16
219# define htobe16(x) htons(x)
220#endif
221#ifndef htobe32
222# define htobe32(x) htonl(x)
223#endif
224#ifndef be16toh
225# define be16toh(x) ntohs(x)
226#endif
227#ifndef be32toh
228# define be32toh(x) ntohl(x)
229#endif
230
231#define HTOBE16(x) (x) = htobe16(x)
232#define HTOBE32(x) (x) = htobe32(x)
233#define BE32TOH(x) (x) = be32toh(x)
234#define BE16TOH(x) (x) = be16toh(x)
235
236EOF
237
238 if test $ac_cv_c_bigendian = yes; then
239  cat >> "$1" << EOF
240/* Define our own extended byte swapping macros for big-endian machines */
241#ifndef htole16
242# define htole16(x)      swap16(x)
243#endif
244#ifndef htole32
245# define htole32(x)      swap32(x)
246#endif
247#ifndef le16toh
248# define le16toh(x)      swap16(x)
249#endif
250#ifndef le32toh
251# define le32toh(x)      swap32(x)
252#endif
253#ifndef le64toh
254# define le64toh(x)      swap64(x)
255#endif
256
257#ifndef htobe64
258# define htobe64(x)      (x)
259#endif
260#ifndef be64toh
261# define be64toh(x)      (x)
262#endif
263
264#define HTOLE16(x)      (x) = htole16(x)
265#define HTOLE32(x)      (x) = htole32(x)
266#define LE16TOH(x)      (x) = le16toh(x)
267#define LE32TOH(x)      (x) = le32toh(x)
268#define LE64TOH(x)      (x) = le64toh(x)
269
270#define HTOBE64(x)      (void) (x)
271#define BE64TOH(x)      (void) (x)
272
273EOF
274 else
275  cat >> "$1" << EOF
276/* On little endian machines, these macros are null */
277#ifndef htole16
278# define htole16(x)      (x)
279#endif
280#ifndef htole32
281# define htole32(x)      (x)
282#endif
283#ifndef htole64
284# define htole64(x)      (x)
285#endif
286#ifndef le16toh
287# define le16toh(x)      (x)
288#endif
289#ifndef le32toh
290# define le32toh(x)      (x)
291#endif
292#ifndef le64toh
293# define le64toh(x)      (x)
294#endif
295
296#define HTOLE16(x)      (void) (x)
297#define HTOLE32(x)      (void) (x)
298#define HTOLE64(x)      (void) (x)
299#define LE16TOH(x)      (void) (x)
300#define LE32TOH(x)      (void) (x)
301#define LE64TOH(x)      (void) (x)
302
303/* These don't have standard aliases */
304#ifndef htobe64
305# define htobe64(x)      swap64(x)
306#endif
307#ifndef be64toh
308# define be64toh(x)      swap64(x)
309#endif
310
311#define HTOBE64(x)      (x) = htobe64(x)
312#define BE64TOH(x)      (x) = be64toh(x)
313
314EOF
315 fi
316fi
317
318cat >> "$1" << EOF
319/* Define the C99 standard length-specific integer types */
320#include <_stdint.h>
321
322EOF
323
324case "${effective_target}" in
325 i[3456]86-*)
326  cat >> "$1" << EOF
327/* Here are some macros to create integers from a byte array */
328/* These are used to get and put integers from/into a uint8_t array */
329/* with a specific endianness.  This is the most portable way to generate */
330/* and read messages to a network or serial device.  Each member of a */
331/* packet structure must be handled separately. */
332
333/* The i386 and compatibles can handle unaligned memory access, */
334/* so use the optimized macros above to do this job */
335#ifndef be16atoh
336# define be16atoh(x)     be16toh(*(uint16_t*)(x))
337#endif
338#ifndef be32atoh
339# define be32atoh(x)     be32toh(*(uint32_t*)(x))
340#endif
341#ifndef be64atoh
342# define be64atoh(x)     be64toh(*(uint64_t*)(x))
343#endif
344#ifndef le16atoh
345# define le16atoh(x)     le16toh(*(uint16_t*)(x))
346#endif
347#ifndef le32atoh
348# define le32atoh(x)     le32toh(*(uint32_t*)(x))
349#endif
350#ifndef le64atoh
351# define le64atoh(x)     le64toh(*(uint64_t*)(x))
352#endif
353
354#ifndef htob16a
355# define htobe16a(a,x)   *(uint16_t*)(a) = htobe16(x)
356#endif
357#ifndef htobe32a
358# define htobe32a(a,x)   *(uint32_t*)(a) = htobe32(x)
359#endif
360#ifndef htobe64a
361# define htobe64a(a,x)   *(uint64_t*)(a) = htobe64(x)
362#endif
363#ifndef htole16a
364# define htole16a(a,x)   *(uint16_t*)(a) = htole16(x)
365#endif
366#ifndef htole32a
367# define htole32a(a,x)   *(uint32_t*)(a) = htole32(x)
368#endif
369#ifndef htole64a
370# define htole64a(a,x)   *(uint64_t*)(a) = htole64(x)
371#endif
372
373EOF
374  ;;
375
376 *)
377  cat >> "$1" << EOF
378/* Here are some macros to create integers from a byte array */
379/* These are used to get and put integers from/into a uint8_t array */
380/* with a specific endianness.  This is the most portable way to generate */
381/* and read messages to a network or serial device.  Each member of a */
382/* packet structure must be handled separately. */
383
384/* Non-optimized but portable macros */
385#define be16atoh(x)     ((uint16_t)(((x)[0]<<8)|(x)[1]))
386#define be32atoh(x)     ((uint32_t)(((x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3]))
387#define be64atoh_x(x,off,shift) 	(((uint64_t)((x)[off]))<<shift)
388#define be64atoh(x)     ((uint64_t)(be64atoh_x(x,0,56)|be64atoh_x(x,1,48)|be64atoh_x(x,2,40)| \\
389        be64atoh_x(x,3,32)|be64atoh_x(x,4,24)|be64atoh_x(x,5,16)|be64atoh_x(x,6,8)|((x)[7])))
390#define le16atoh(x)     ((uint16_t)(((x)[1]<<8)|(x)[0]))
391#define le32atoh(x)     ((uint32_t)(((x)[3]<<24)|((x)[2]<<16)|((x)[1]<<8)|(x)[0]))
392#define le64atoh_x(x,off,shift) (((uint64_t)(x)[off])<<shift)
393#define le64atoh(x)     ((uint64_t)(le64atoh_x(x,7,56)|le64atoh_x(x,6,48)|le64atoh_x(x,5,40)| \\
394        le64atoh_x(x,4,32)|le64atoh_x(x,3,24)|le64atoh_x(x,2,16)|le64atoh_x(x,1,8)|((x)[0])))
395
396#define htobe16a(a,x)   (a)[0]=(uint8_t)((x)>>8), (a)[1]=(uint8_t)(x)
397#define htobe32a(a,x)   (a)[0]=(uint8_t)((x)>>24), (a)[1]=(uint8_t)((x)>>16), \\
398        (a)[2]=(uint8_t)((x)>>8), (a)[3]=(uint8_t)(x)
399#define htobe64a(a,x)   (a)[0]=(uint8_t)((x)>>56), (a)[1]=(uint8_t)((x)>>48), \\
400        (a)[2]=(uint8_t)((x)>>40), (a)[3]=(uint8_t)((x)>>32), \\
401        (a)[4]=(uint8_t)((x)>>24), (a)[5]=(uint8_t)((x)>>16), \\
402        (a)[6]=(uint8_t)((x)>>8), (a)[7]=(uint8_t)(x)
403#define htole16a(a,x)   (a)[1]=(uint8_t)((x)>>8), (a)[0]=(uint8_t)(x)
404#define htole32a(a,x)   (a)[3]=(uint8_t)((x)>>24), (a)[2]=(uint8_t)((x)>>16), \\
405        (a)[1]=(uint8_t)((x)>>8), (a)[0]=(uint8_t)(x)
406#define htole64a(a,x)   (a)[7]=(uint8_t)((x)>>56), (a)[6]=(uint8_t)((x)>>48), \\
407        (a)[5]=(uint8_t)((x)>>40), (a)[4]=(uint8_t)((x)>>32), \\
408        (a)[3]=(uint8_t)((x)>>24), (a)[2]=(uint8_t)((x)>>16), \\
409        (a)[1]=(uint8_t)((x)>>8), (a)[0]=(uint8_t)(x)
410
411EOF
412  ;;
413esac
414]
415
416cat >> "$1" << EOF
417#endif /*__BYTEORDER_H*/
418EOF])
419