[mirror_ovs.git] / lib / unaligned.h

/*
 * Copyright (c) 2010, 2011, 2014 Nicira, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef UNALIGNED_H
#define UNALIGNED_H 1

#include <stdint.h>
#include "byte-order.h"
#include "openvswitch/types.h"
#include "openvswitch/type-props.h"
#include "util.h"

/* Public API. */
static inline uint16_t get_unaligned_u16(const uint16_t *);
static inline uint32_t get_unaligned_u32(const uint32_t *);
static inline void put_unaligned_u16(uint16_t *, uint16_t);
static inline void put_unaligned_u32(uint32_t *, uint32_t);
static inline void put_unaligned_u64(uint64_t *, uint64_t);

static inline ovs_be16 get_unaligned_be16(const ovs_be16 *);
static inline ovs_be32 get_unaligned_be32(const ovs_be32 *);
static inline ovs_be64 get_unaligned_be64(const ovs_be64 *);
static inline void put_unaligned_be16(ovs_be16 *, ovs_be16);
static inline void put_unaligned_be32(ovs_be32 *, ovs_be32);
static inline void put_unaligned_be64(ovs_be64 *, ovs_be64);

/* uint64_t get_unaligned_u64(uint64_t *p);
 *
 * Returns the value of the possibly misaligned uint64_t at 'p'.  'p' may
 * actually be any type that points to a 64-bit integer.  That is, on Unix-like
 * 32-bit ABIs, it may point to an "unsigned long long int", and on Unix-like
 * 64-bit ABIs, it may point to an "unsigned long int" or an "unsigned long
 * long int".
 *
 * This is special-cased because on some Linux targets, the kernel __u64 is
 * unsigned long long int and the userspace uint64_t is unsigned long int, so
 * that any single function prototype would fail to accept one or the other.
 *
 * Below, "sizeof (*(P) % 1)" verifies that *P has an integer type, since
 * operands to % must be integers.
 */
#define get_unaligned_u64(P)                                \
    (BUILD_ASSERT(sizeof *(P) == 8),                        \
     BUILD_ASSERT_GCCONLY(!TYPE_IS_SIGNED(typeof(*(P)))),   \
     (void) sizeof (*(P) % 1),                              \
     get_unaligned_u64__((const uint64_t *) (P)))

#ifdef __GNUC__
/* GCC implementations. */
#define GCC_UNALIGNED_ACCESSORS(TYPE, ABBREV)   \
struct unaligned_##ABBREV {                     \
    TYPE x __attribute__((__packed__));         \
};                                              \
static inline struct unaligned_##ABBREV *       \
unaligned_##ABBREV(const TYPE *p)               \
{                                               \
    return (struct unaligned_##ABBREV *) p;     \
}                                               \
                                                \
static inline TYPE                              \
get_unaligned_##ABBREV(const TYPE *p)           \
{                                               \
    return unaligned_##ABBREV(p)->x;            \
}                                               \
                                                \
static inline void                              \
put_unaligned_##ABBREV(TYPE *p, TYPE x)         \
{                                               \
    unaligned_##ABBREV(p)->x = x;               \
}

GCC_UNALIGNED_ACCESSORS(uint16_t, u16);
GCC_UNALIGNED_ACCESSORS(uint32_t, u32);
GCC_UNALIGNED_ACCESSORS(uint64_t, u64__); /* Special case: see below. */

GCC_UNALIGNED_ACCESSORS(ovs_be16, be16);
GCC_UNALIGNED_ACCESSORS(ovs_be32, be32);
GCC_UNALIGNED_ACCESSORS(ovs_be64, be64);
#else
/* Generic implementations. */

static inline uint16_t get_unaligned_u16(const uint16_t *p_)
{
    const uint8_t *p = (const uint8_t *) p_;
    return ntohs((p[0] << 8) | p[1]);
}

static inline void put_unaligned_u16(uint16_t *p_, uint16_t x_)
{
    uint8_t *p = (uint8_t *) p_;
    uint16_t x = ntohs(x_);

    p[0] = x >> 8;
    p[1] = x;
}

static inline uint32_t get_unaligned_u32(const uint32_t *p_)
{
    const uint8_t *p = (const uint8_t *) p_;
    return ntohl((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
}

static inline void put_unaligned_u32(uint32_t *p_, uint32_t x_)
{
    uint8_t *p = (uint8_t *) p_;
    uint32_t x = ntohl(x_);

    p[0] = x >> 24;
    p[1] = x >> 16;
    p[2] = x >> 8;
    p[3] = x;
}

static inline uint64_t get_unaligned_u64__(const uint64_t *p_)
{
    const uint8_t *p = (const uint8_t *) p_;
    return ntohll(((uint64_t) p[0] << 56)
                  | ((uint64_t) p[1] << 48)
                  | ((uint64_t) p[2] << 40)
                  | ((uint64_t) p[3] << 32)
                  | (p[4] << 24)
                  | (p[5] << 16)
                  | (p[6] << 8)
                  | p[7]);
}

static inline void put_unaligned_u64__(uint64_t *p_, uint64_t x_)
{
    uint8_t *p = (uint8_t *) p_;
    uint64_t x = ntohll(x_);

    p[0] = x >> 56;
    p[1] = x >> 48;
    p[2] = x >> 40;
    p[3] = x >> 32;
    p[4] = x >> 24;
    p[5] = x >> 16;
    p[6] = x >> 8;
    p[7] = x;
}

/* Only sparse cares about the difference between uint<N>_t and ovs_be<N>, and
 * that takes the GCC branch, so there's no point in working too hard on these
 * accessors. */
#define get_unaligned_be16 get_unaligned_u16
#define get_unaligned_be32 get_unaligned_u32
#define put_unaligned_be16 put_unaligned_u16
#define put_unaligned_be32 put_unaligned_u32
#define put_unaligned_be64 put_unaligned_u64

/* We do not #define get_unaligned_be64 as for the other be<N> functions above,
 * because such a definition would mean that get_unaligned_be64() would have a
 * different interface in each branch of the #if: with GCC it would take a
 * "ovs_be64 *", with other compilers any pointer-to-64-bit-type (but not void
 * *).  The latter means code like "get_unaligned_be64(ofpbuf_data(b))" would
 * work with GCC but not with other compilers, which is surprising and
 * undesirable.  Hence this wrapper function. */
static inline ovs_be64
get_unaligned_be64(const ovs_be64 *p)
{
    return get_unaligned_u64(p);
}
#endif

/* Stores 'x' at possibly misaligned address 'p'.
 *
 * put_unaligned_u64() could be overloaded in the same way as
 * get_unaligned_u64(), but so far it has not proven necessary.
 */
static inline void
put_unaligned_u64(uint64_t *p, uint64_t x)
{
    put_unaligned_u64__(p, x);
}
\f
/* Returns the value in 'x'. */
static inline uint32_t
get_16aligned_u32(const ovs_16aligned_u32 *x)
{
    return ((uint32_t) x->hi << 16) | x->lo;
}

/* Stores 'value' in 'x'. */
static inline void
put_16aligned_u32(ovs_16aligned_u32 *x, uint32_t value)
{
    x->hi = value >> 16;
    x->lo = value;
}

/* Returns the value in 'x'. */
static inline uint64_t
get_32aligned_u64(const ovs_32aligned_u64 *x)
{
    return ((uint64_t) x->hi << 32) | x->lo;
}

/* Stores 'value' in 'x'. */
static inline void
put_32aligned_u64(ovs_32aligned_u64 *x, uint64_t value)
{
    x->hi = value >> 32;
    x->lo = value;
}

/* Returns the value in 'x'. */
static inline ovs_u128
get_32aligned_u128(const ovs_32aligned_u128 *x)
{
    ovs_u128 u = { .u32 = { x->u32[0], x->u32[1], x->u32[2], x->u32[3] } };
    return u;
}

/* Stores 'value' in 'x'. */
static inline void
put_32aligned_u128(ovs_32aligned_u128 *x, ovs_u128 value)
{
    x->u32[0] = value.u32[0];
    x->u32[1] = value.u32[1];
    x->u32[2] = value.u32[2];
    x->u32[3] = value.u32[3];
}

#ifndef __CHECKER__
/* Returns the value of 'x'. */
static inline ovs_be32
get_16aligned_be32(const ovs_16aligned_be32 *x)
{
#ifdef WORDS_BIGENDIAN
    return ((ovs_be32) x->hi << 16) | x->lo;
#else
    return ((ovs_be32) x->lo << 16) | x->hi;
#endif
}

/* Stores network byte order 'value' into 'x'. */
static inline void
put_16aligned_be32(ovs_16aligned_be32 *x, ovs_be32 value)
{
#if WORDS_BIGENDIAN
    x->hi = value >> 16;
    x->lo = value;
#else
    x->hi = value;
    x->lo = value >> 16;
#endif
}

/* Returns the value of 'x'. */
static inline ovs_be64
get_32aligned_be64(const ovs_32aligned_be64 *x)
{
#ifdef WORDS_BIGENDIAN
    return ((ovs_be64) x->hi << 32) | x->lo;
#else
    return ((ovs_be64) x->lo << 32) | x->hi;
#endif
}

/* Stores network byte order 'value' into 'x'. */
static inline void
put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value)
{
#if WORDS_BIGENDIAN
    x->hi = value >> 32;
    x->lo = value;
#else
    x->hi = value;
    x->lo = value >> 32;
#endif
}

/* Returns the value of 'x'. */
static inline ovs_be128
get_32aligned_be128(const ovs_32aligned_be128 *x)
{
    ovs_be128 u = { .be32 = { x->be32[0], x->be32[1],
                              x->be32[2], x->be32[3] } };
    return u;
}

/* Stores network byte order 'value' into 'x'. */
static inline void
put_32aligned_be128(ovs_32aligned_be128 *x, ovs_be128 value)
{
    x->be32[0] = value.be32[0];
    x->be32[1] = value.be32[1];
    x->be32[2] = value.be32[2];
    x->be32[3] = value.be32[3];
}
#else  /* __CHECKER__ */
/* Making sparse happy with these functions also makes them unreadable, so
 * don't bother to show it their implementations. */
ovs_be32 get_16aligned_be32(const ovs_16aligned_be32 *);
void put_16aligned_be32(ovs_16aligned_be32 *, ovs_be32);
ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *);
void put_32aligned_be64(ovs_32aligned_be64 *, ovs_be64);
ovs_be128 get_32aligned_be128(const ovs_32aligned_be128 *);
void put_32aligned_be128(ovs_32aligned_be128 *, ovs_be128);
#endif

#endif /* unaligned.h */
Commit	Line	Data
afa3a931	1	/*
79461d20	2	* Copyright (c) 2010, 2011, 2014 Nicira, Inc.
afa3a931 BP	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at:
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*/
	16
	17	#ifndef UNALIGNED_H
	18	#define UNALIGNED_H 1
	19
	20	#include <stdint.h>
10a24935	21	#include "byte-order.h"
9ea5d2d5	22	#include "openvswitch/types.h"
ae06a561	23	#include "openvswitch/type-props.h"
320232ec	24	#include "util.h"
afa3a931 BP	25
	26	/* Public API. */
	27	static inline uint16_t get_unaligned_u16(const uint16_t *);
	28	static inline uint32_t get_unaligned_u32(const uint32_t *);
afa3a931 BP	29	static inline void put_unaligned_u16(uint16_t *, uint16_t);
	30	static inline void put_unaligned_u32(uint32_t *, uint32_t);
	31	static inline void put_unaligned_u64(uint64_t *, uint64_t);
	32
9ea5d2d5 BP	33	static inline ovs_be16 get_unaligned_be16(const ovs_be16 *);
	34	static inline ovs_be32 get_unaligned_be32(const ovs_be32 *);
	35	static inline ovs_be64 get_unaligned_be64(const ovs_be64 *);
	36	static inline void put_unaligned_be16(ovs_be16 *, ovs_be16);
	37	static inline void put_unaligned_be32(ovs_be32 *, ovs_be32);
	38	static inline void put_unaligned_be64(ovs_be64 *, ovs_be64);
	39
79461d20 BP	40	/* uint64_t get_unaligned_u64(uint64_t *p);
	41	*
	42	* Returns the value of the possibly misaligned uint64_t at 'p'. 'p' may
	43	* actually be any type that points to a 64-bit integer. That is, on Unix-like
	44	* 32-bit ABIs, it may point to an "unsigned long long int", and on Unix-like
	45	* 64-bit ABIs, it may point to an "unsigned long int" or an "unsigned long
	46	* long int".
	47	*
	48	* This is special-cased because on some Linux targets, the kernel __u64 is
	49	* unsigned long long int and the userspace uint64_t is unsigned long int, so
	50	* that any single function prototype would fail to accept one or the other.
	51	*
	52	* Below, "sizeof ((P) % 1)" verifies that P has an integer type, since
	53	* operands to % must be integers.
	54	*/
	55	#define get_unaligned_u64(P) \
	56	(BUILD_ASSERT(sizeof *(P) == 8), \
	57	BUILD_ASSERT_GCCONLY(!TYPE_IS_SIGNED(typeof(*(P)))), \
	58	(void) sizeof (*(P) % 1), \
	59	get_unaligned_u64__((const uint64_t *) (P)))
	60
afa3a931 BP	61	#ifdef __GNUC__
afa3a931 BP	62	/* GCC implementations. */
9ea5d2d5 BP	63	#define GCC_UNALIGNED_ACCESSORS(TYPE, ABBREV) \
	64	struct unaligned_##ABBREV { \
	65	TYPE x __attribute__((__packed__)); \
	66	}; \
	67	static inline struct unaligned_##ABBREV * \
	68	unaligned_##ABBREV(const TYPE *p) \
	69	{ \
	70	return (struct unaligned_##ABBREV *) p; \
	71	} \
	72	\
	73	static inline TYPE \
	74	get_unaligned_##ABBREV(const TYPE *p) \
	75	{ \
	76	return unaligned_##ABBREV(p)->x; \
	77	} \
	78	\
	79	static inline void \
	80	put_unaligned_##ABBREV(TYPE *p, TYPE x) \
	81	{ \
	82	unaligned_##ABBREV(p)->x = x; \
afa3a931 BP	83	}
afa3a931 BP	84
9ea5d2d5 BP	85	GCC_UNALIGNED_ACCESSORS(uint16_t, u16);
9ea5d2d5 BP	86	GCC_UNALIGNED_ACCESSORS(uint32_t, u32);
320232ec	87	GCC_UNALIGNED_ACCESSORS(uint64_t, u64__); /* Special case: see below. */
9ea5d2d5 BP	88
	89	GCC_UNALIGNED_ACCESSORS(ovs_be16, be16);
	90	GCC_UNALIGNED_ACCESSORS(ovs_be32, be32);
	91	GCC_UNALIGNED_ACCESSORS(ovs_be64, be64);
afa3a931 BP	92	#else
	93	/* Generic implementations. */
	94
	95	static inline uint16_t get_unaligned_u16(const uint16_t *p_)
	96	{
	97	const uint8_t p = (const uint8_t ) p_;
	98	return ntohs((p[0] << 8) \| p[1]);
	99	}
	100
	101	static inline void put_unaligned_u16(uint16_t *p_, uint16_t x_)
	102	{
	103	uint8_t p = (uint8_t ) p_;
	104	uint16_t x = ntohs(x_);
	105
	106	p[0] = x >> 8;
	107	p[1] = x;
	108	}
	109
	110	static inline uint32_t get_unaligned_u32(const uint32_t *p_)
	111	{
	112	const uint8_t p = (const uint8_t ) p_;
	113	return ntohl((p[0] << 24) \| (p[1] << 16) \| (p[2] << 8) \| p[3]);
	114	}
	115
	116	static inline void put_unaligned_u32(uint32_t *p_, uint32_t x_)
	117	{
	118	uint8_t p = (uint8_t ) p_;
	119	uint32_t x = ntohl(x_);
	120
	121	p[0] = x >> 24;
	122	p[1] = x >> 16;
	123	p[2] = x >> 8;
	124	p[3] = x;
	125	}
	126
320232ec	127	static inline uint64_t get_unaligned_u64__(const uint64_t *p_)
afa3a931 BP	128	{
	129	const uint8_t p = (const uint8_t ) p_;
	130	return ntohll(((uint64_t) p[0] << 56)
	131	\| ((uint64_t) p[1] << 48)
	132	\| ((uint64_t) p[2] << 40)
	133	\| ((uint64_t) p[3] << 32)
	134	\| (p[4] << 24)
	135	\| (p[5] << 16)
	136	\| (p[6] << 8)
	137	\| p[7]);
	138	}
	139
320232ec	140	static inline void put_unaligned_u64__(uint64_t *p_, uint64_t x_)
afa3a931 BP	141	{
	142	uint8_t p = (uint8_t ) p_;
	143	uint64_t x = ntohll(x_);
	144
	145	p[0] = x >> 56;
	146	p[1] = x >> 48;
	147	p[2] = x >> 40;
	148	p[3] = x >> 32;
	149	p[4] = x >> 24;
	150	p[5] = x >> 16;
	151	p[6] = x >> 8;
	152	p[7] = x;
	153	}
9ea5d2d5 BP	154
	155	/* Only sparse cares about the difference between uint<N>_t and ovs_be<N>, and
	156	* that takes the GCC branch, so there's no point in working too hard on these
	157	* accessors. */
	158	#define get_unaligned_be16 get_unaligned_u16
	159	#define get_unaligned_be32 get_unaligned_u32
9ea5d2d5 BP	160	#define put_unaligned_be16 put_unaligned_u16
	161	#define put_unaligned_be32 put_unaligned_u32
	162	#define put_unaligned_be64 put_unaligned_u64
320232ec	163
79461d20 BP	164	/* We do not #define get_unaligned_be64 as for the other be<N> functions above,
	165	* because such a definition would mean that get_unaligned_be64() would have a
	166	* different interface in each branch of the #if: with GCC it would take a
	167	* "ovs_be64 *", with other compilers any pointer-to-64-bit-type (but not void
	168	* *). The latter means code like "get_unaligned_be64(ofpbuf_data(b))" would
	169	* work with GCC but not with other compilers, which is surprising and
	170	* undesirable. Hence this wrapper function. */
	171	static inline ovs_be64
	172	get_unaligned_be64(const ovs_be64 *p)
	173	{
	174	return get_unaligned_u64(p);
	175	}
	176	#endif
320232ec BP	177
	178	/* Stores 'x' at possibly misaligned address 'p'.
	179	*
	180	* put_unaligned_u64() could be overloaded in the same way as
	181	* get_unaligned_u64(), but so far it has not proven necessary.
	182	*/
	183	static inline void
	184	put_unaligned_u64(uint64_t *p, uint64_t x)
	185	{
	186	put_unaligned_u64__(p, x);
	187	}
7bef2c91	188	\f
7c457c33 BP	189	/* Returns the value in 'x'. */
	190	static inline uint32_t
	191	get_16aligned_u32(const ovs_16aligned_u32 *x)
	192	{
	193	return ((uint32_t) x->hi << 16) \| x->lo;
	194	}
	195
	196	/* Stores 'value' in 'x'. */
	197	static inline void
	198	put_16aligned_u32(ovs_16aligned_u32 *x, uint32_t value)
	199	{
	200	x->hi = value >> 16;
	201	x->lo = value;
	202	}
	203
7bef2c91 BP	204	/* Returns the value in 'x'. */
	205	static inline uint64_t
	206	get_32aligned_u64(const ovs_32aligned_u64 *x)
	207	{
05fe1764	208	return ((uint64_t) x->hi << 32) \| x->lo;
7bef2c91 BP	209	}
	210
	211	/* Stores 'value' in 'x'. */
	212	static inline void
	213	put_32aligned_u64(ovs_32aligned_u64 *x, uint64_t value)
	214	{
05fe1764 BP	215	x->hi = value >> 32;
05fe1764 BP	216	x->lo = value;
7bef2c91 BP	217	}
7bef2c91 BP	218
62a78fe5 BP	219	/* Returns the value in 'x'. */
	220	static inline ovs_u128
	221	get_32aligned_u128(const ovs_32aligned_u128 *x)
	222	{
	223	ovs_u128 u = { .u32 = { x->u32[0], x->u32[1], x->u32[2], x->u32[3] } };
	224	return u;
	225	}
	226
	227	/* Stores 'value' in 'x'. */
	228	static inline void
	229	put_32aligned_u128(ovs_32aligned_u128 *x, ovs_u128 value)
	230	{
	231	x->u32[0] = value.u32[0];
	232	x->u32[1] = value.u32[1];
	233	x->u32[2] = value.u32[2];
	234	x->u32[3] = value.u32[3];
	235	}
	236
6506f45c	237	#ifndef __CHECKER__
7c457c33 BP	238	/* Returns the value of 'x'. */
	239	static inline ovs_be32
	240	get_16aligned_be32(const ovs_16aligned_be32 *x)
	241	{
	242	#ifdef WORDS_BIGENDIAN
	243	return ((ovs_be32) x->hi << 16) \| x->lo;
	244	#else
	245	return ((ovs_be32) x->lo << 16) \| x->hi;
	246	#endif
	247	}
	248
	249	/* Stores network byte order 'value' into 'x'. */
	250	static inline void
	251	put_16aligned_be32(ovs_16aligned_be32 *x, ovs_be32 value)
	252	{
	253	#if WORDS_BIGENDIAN
	254	x->hi = value >> 16;
	255	x->lo = value;
	256	#else
	257	x->hi = value;
	258	x->lo = value >> 16;
	259	#endif
	260	}
	261
7bef2c91 BP	262	/* Returns the value of 'x'. */
	263	static inline ovs_be64
	264	get_32aligned_be64(const ovs_32aligned_be64 *x)
	265	{
	266	#ifdef WORDS_BIGENDIAN
05fe1764	267	return ((ovs_be64) x->hi << 32) \| x->lo;
7bef2c91	268	#else
05fe1764	269	return ((ovs_be64) x->lo << 32) \| x->hi;
7bef2c91 BP	270	#endif
	271	}
	272
	273	/* Stores network byte order 'value' into 'x'. */
	274	static inline void
	275	put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value)
	276	{
	277	#if WORDS_BIGENDIAN
05fe1764 BP	278	x->hi = value >> 32;
05fe1764 BP	279	x->lo = value;
7bef2c91 BP	280	#else
	281	x->hi = value;
	282	x->lo = value >> 32;
	283	#endif
	284	}
62a78fe5 BP	285
	286	/* Returns the value of 'x'. */
	287	static inline ovs_be128
	288	get_32aligned_be128(const ovs_32aligned_be128 *x)
	289	{
	290	ovs_be128 u = { .be32 = { x->be32[0], x->be32[1],
	291	x->be32[2], x->be32[3] } };
	292	return u;
	293	}
	294
	295	/* Stores network byte order 'value' into 'x'. */
	296	static inline void
	297	put_32aligned_be128(ovs_32aligned_be128 *x, ovs_be128 value)
	298	{
	299	x->be32[0] = value.be32[0];
	300	x->be32[1] = value.be32[1];
	301	x->be32[2] = value.be32[2];
	302	x->be32[3] = value.be32[3];
	303	}
6506f45c BP	304	#else /* __CHECKER__ */
	305	/* Making sparse happy with these functions also makes them unreadable, so
	306	* don't bother to show it their implementations. */
7c457c33 BP	307	ovs_be32 get_16aligned_be32(const ovs_16aligned_be32 *);
7c457c33 BP	308	void put_16aligned_be32(ovs_16aligned_be32 *, ovs_be32);
6506f45c BP	309	ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *);
6506f45c BP	310	void put_32aligned_be64(ovs_32aligned_be64 *, ovs_be64);
62a78fe5 BP	311	ovs_be128 get_32aligned_be128(const ovs_32aligned_be128 *);
62a78fe5 BP	312	void put_32aligned_be128(ovs_32aligned_be128 *, ovs_be128);
6506f45c	313	#endif
afa3a931 BP	314
afa3a931 BP	315	#endif /* unaligned.h */