2 * Copyright (c) 2010, 2011 Nicira, Inc.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include "byte-order.h"
22 #include "openvswitch/types.h"
23 #include "type-props.h"
27 static inline uint16_t get_unaligned_u16(const uint16_t *);
28 static inline uint32_t get_unaligned_u32(const uint32_t *);
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);
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);
41 /* GCC implementations. */
42 #define GCC_UNALIGNED_ACCESSORS(TYPE, ABBREV) \
43 struct unaligned_##ABBREV { \
44 TYPE x __attribute__((__packed__)); \
46 static inline struct unaligned_##ABBREV * \
47 unaligned_##ABBREV(const TYPE *p) \
49 return (struct unaligned_##ABBREV *) p; \
53 get_unaligned_##ABBREV(const TYPE *p) \
55 return unaligned_##ABBREV(p)->x; \
59 put_unaligned_##ABBREV(TYPE *p, TYPE x) \
61 unaligned_##ABBREV(p)->x = x; \
64 GCC_UNALIGNED_ACCESSORS(uint16_t, u16);
65 GCC_UNALIGNED_ACCESSORS(uint32_t, u32);
66 GCC_UNALIGNED_ACCESSORS(uint64_t, u64__); /* Special case: see below. */
68 GCC_UNALIGNED_ACCESSORS(ovs_be16, be16);
69 GCC_UNALIGNED_ACCESSORS(ovs_be32, be32);
70 GCC_UNALIGNED_ACCESSORS(ovs_be64, be64);
72 /* Generic implementations. */
74 static inline uint16_t get_unaligned_u16(const uint16_t *p_)
76 const uint8_t *p = (const uint8_t *) p_;
77 return ntohs((p[0] << 8) | p[1]);
80 static inline void put_unaligned_u16(uint16_t *p_, uint16_t x_)
82 uint8_t *p = (uint8_t *) p_;
83 uint16_t x = ntohs(x_);
89 static inline uint32_t get_unaligned_u32(const uint32_t *p_)
91 const uint8_t *p = (const uint8_t *) p_;
92 return ntohl((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
95 static inline void put_unaligned_u32(uint32_t *p_, uint32_t x_)
97 uint8_t *p = (uint8_t *) p_;
98 uint32_t x = ntohl(x_);
106 static inline uint64_t get_unaligned_u64__(const uint64_t *p_)
108 const uint8_t *p = (const uint8_t *) p_;
109 return ntohll(((uint64_t) p[0] << 56)
110 | ((uint64_t) p[1] << 48)
111 | ((uint64_t) p[2] << 40)
112 | ((uint64_t) p[3] << 32)
119 static inline void put_unaligned_u64__(uint64_t *p_, uint64_t x_)
121 uint8_t *p = (uint8_t *) p_;
122 uint64_t x = ntohll(x_);
134 /* Only sparse cares about the difference between uint<N>_t and ovs_be<N>, and
135 * that takes the GCC branch, so there's no point in working too hard on these
137 #define get_unaligned_be16 get_unaligned_u16
138 #define get_unaligned_be32 get_unaligned_u32
139 #define get_unaligned_be64 get_unaligned_u64
140 #define put_unaligned_be16 put_unaligned_u16
141 #define put_unaligned_be32 put_unaligned_u32
142 #define put_unaligned_be64 put_unaligned_u64
145 /* uint64_t get_unaligned_u64(uint64_t *p);
147 * Returns the value of the possibly misaligned uint64_t at 'p'. 'p' may
148 * actually be any type that points to a 64-bit integer. That is, on Unix-like
149 * 32-bit ABIs, it may point to an "unsigned long long int", and on Unix-like
150 * 64-bit ABIs, it may point to an "unsigned long int" or an "unsigned long
153 * This is special-cased because on some Linux targets, the kernel __u64 is
154 * unsigned long long int and the userspace uint64_t is unsigned long int, so
155 * that any single function prototype would fail to accept one or the other.
157 * Below, "sizeof (*(P) % 1)" verifies that *P has an integer type, since
158 * operands to % must be integers.
160 #define get_unaligned_u64(P) \
161 (BUILD_ASSERT(sizeof *(P) == 8), \
162 BUILD_ASSERT_GCCONLY(!TYPE_IS_SIGNED(typeof(*(P)))), \
163 (void) sizeof (*(P) % 1), \
164 get_unaligned_u64__((const uint64_t *) (P)))
166 /* Stores 'x' at possibly misaligned address 'p'.
168 * put_unaligned_u64() could be overloaded in the same way as
169 * get_unaligned_u64(), but so far it has not proven necessary.
172 put_unaligned_u64(uint64_t *p, uint64_t x)
174 put_unaligned_u64__(p, x);
177 /* Returns the value in 'x'. */
178 static inline uint64_t
179 get_32aligned_u64(const ovs_32aligned_u64 *x)
181 return ((uint64_t) x->hi << 32) | x->lo;
184 /* Stores 'value' in 'x'. */
186 put_32aligned_u64(ovs_32aligned_u64 *x, uint64_t value)
193 /* Returns the value of 'x'. */
194 static inline ovs_be64
195 get_32aligned_be64(const ovs_32aligned_be64 *x)
197 #ifdef WORDS_BIGENDIAN
198 return ((ovs_be64) x->hi << 32) | x->lo;
200 return ((ovs_be64) x->lo << 32) | x->hi;
204 /* Stores network byte order 'value' into 'x'. */
206 put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value)
216 #else /* __CHECKER__ */
217 /* Making sparse happy with these functions also makes them unreadable, so
218 * don't bother to show it their implementations. */
219 ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *);
220 void put_32aligned_be64(ovs_32aligned_be64 *, ovs_be64);
223 #endif /* unaligned.h */