AUTHORS: Add Valient Gough.
[openvswitch] / lib / unaligned.h
1 /*
2  * Copyright (c) 2010, 2011 Nicira Networks.
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>
21 #include "byte-order.h"
22 #include "openvswitch/types.h"
23
24 /* Public API. */
25 static inline uint16_t get_unaligned_u16(const uint16_t *);
26 static inline uint32_t get_unaligned_u32(const uint32_t *);
27 static inline uint64_t get_unaligned_u64(const uint64_t *);
28 static inline void put_unaligned_u16(uint16_t *, uint16_t);
29 static inline void put_unaligned_u32(uint32_t *, uint32_t);
30 static inline void put_unaligned_u64(uint64_t *, uint64_t);
31
32 static inline ovs_be16 get_unaligned_be16(const ovs_be16 *);
33 static inline ovs_be32 get_unaligned_be32(const ovs_be32 *);
34 static inline ovs_be64 get_unaligned_be64(const ovs_be64 *);
35 static inline void put_unaligned_be16(ovs_be16 *, ovs_be16);
36 static inline void put_unaligned_be32(ovs_be32 *, ovs_be32);
37 static inline void put_unaligned_be64(ovs_be64 *, ovs_be64);
38
39 #ifdef __GNUC__
40 /* GCC implementations. */
41 #define GCC_UNALIGNED_ACCESSORS(TYPE, ABBREV)   \
42 struct unaligned_##ABBREV {                     \
43     TYPE x __attribute__((__packed__));         \
44 };                                              \
45 static inline struct unaligned_##ABBREV *       \
46 unaligned_##ABBREV(const TYPE *p)               \
47 {                                               \
48     return (struct unaligned_##ABBREV *) p;     \
49 }                                               \
50                                                 \
51 static inline TYPE                              \
52 get_unaligned_##ABBREV(const TYPE *p)           \
53 {                                               \
54     return unaligned_##ABBREV(p)->x;            \
55 }                                               \
56                                                 \
57 static inline void                              \
58 put_unaligned_##ABBREV(TYPE *p, TYPE x)         \
59 {                                               \
60     unaligned_##ABBREV(p)->x = x;               \
61 }
62
63 GCC_UNALIGNED_ACCESSORS(uint16_t, u16);
64 GCC_UNALIGNED_ACCESSORS(uint32_t, u32);
65 GCC_UNALIGNED_ACCESSORS(uint64_t, u64);
66
67 GCC_UNALIGNED_ACCESSORS(ovs_be16, be16);
68 GCC_UNALIGNED_ACCESSORS(ovs_be32, be32);
69 GCC_UNALIGNED_ACCESSORS(ovs_be64, be64);
70 #else
71 /* Generic implementations. */
72
73 static inline uint16_t get_unaligned_u16(const uint16_t *p_)
74 {
75     const uint8_t *p = (const uint8_t *) p_;
76     return ntohs((p[0] << 8) | p[1]);
77 }
78
79 static inline void put_unaligned_u16(uint16_t *p_, uint16_t x_)
80 {
81     uint8_t *p = (uint8_t *) p_;
82     uint16_t x = ntohs(x_);
83
84     p[0] = x >> 8;
85     p[1] = x;
86 }
87
88 static inline uint32_t get_unaligned_u32(const uint32_t *p_)
89 {
90     const uint8_t *p = (const uint8_t *) p_;
91     return ntohl((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
92 }
93
94 static inline void put_unaligned_u32(uint32_t *p_, uint32_t x_)
95 {
96     uint8_t *p = (uint8_t *) p_;
97     uint32_t x = ntohl(x_);
98
99     p[0] = x >> 24;
100     p[1] = x >> 16;
101     p[2] = x >> 8;
102     p[3] = x;
103 }
104
105 static inline uint64_t get_unaligned_u64(const uint64_t *p_)
106 {
107     const uint8_t *p = (const uint8_t *) p_;
108     return ntohll(((uint64_t) p[0] << 56)
109                   | ((uint64_t) p[1] << 48)
110                   | ((uint64_t) p[2] << 40)
111                   | ((uint64_t) p[3] << 32)
112                   | (p[4] << 24)
113                   | (p[5] << 16)
114                   | (p[6] << 8)
115                   | p[7]);
116 }
117
118 static inline void put_unaligned_u64(uint64_t *p_, uint64_t x_)
119 {
120     uint8_t *p = (uint8_t *) p_;
121     uint64_t x = ntohll(x_);
122
123     p[0] = x >> 56;
124     p[1] = x >> 48;
125     p[2] = x >> 40;
126     p[3] = x >> 32;
127     p[4] = x >> 24;
128     p[5] = x >> 16;
129     p[6] = x >> 8;
130     p[7] = x;
131 }
132
133 /* Only sparse cares about the difference between uint<N>_t and ovs_be<N>, and
134  * that takes the GCC branch, so there's no point in working too hard on these
135  * accessors. */
136 #define get_unaligned_be16 get_unaligned_u16
137 #define get_unaligned_be32 get_unaligned_u32
138 #define get_unaligned_be64 get_unaligned_u64
139 #define put_unaligned_be16 put_unaligned_u16
140 #define put_unaligned_be32 put_unaligned_u32
141 #define put_unaligned_be64 put_unaligned_u64
142 #endif
143 \f
144 /* Returns the value in 'x'. */
145 static inline uint64_t
146 get_32aligned_u64(const ovs_32aligned_u64 *x)
147 {
148         return ((uint64_t) x->hi << 32) | x->lo;
149 }
150
151 /* Stores 'value' in 'x'. */
152 static inline void
153 put_32aligned_u64(ovs_32aligned_u64 *x, uint64_t value)
154 {
155         x->hi = value >> 32;
156         x->lo = value;
157 }
158
159 /* Returns the value of 'x'. */
160 static inline ovs_be64
161 get_32aligned_be64(const ovs_32aligned_be64 *x)
162 {
163 #ifdef WORDS_BIGENDIAN
164         return ((ovs_be64) x->hi << 32) | x->lo;
165 #else
166         return ((ovs_be64) x->lo << 32) | x->hi;
167 #endif
168 }
169
170 /* Stores network byte order 'value' into 'x'. */
171 static inline void
172 put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value)
173 {
174 #if WORDS_BIGENDIAN
175         x->hi = value >> 32;
176         x->lo = value;
177 #else
178     x->hi = value;
179     x->lo = value >> 32;
180 #endif
181 }
182
183 #endif /* unaligned.h */