lib/unaligned.h

   1 /*
   2  * Copyright (c) 2010, 2011 Nicira, Inc.
   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 #include "type-props.h"
  24 #include "util.h"
  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 *);
  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
  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
  40 #ifdef __GNUC__
  41 /* GCC implementations. */
  42 #define GCC_UNALIGNED_ACCESSORS(TYPE, ABBREV)   \
  43 struct unaligned_##ABBREV {                     \
  44     TYPE x __attribute__((__packed__));         \
  45 };                                              \
  46 static inline struct unaligned_##ABBREV *       \
  47 unaligned_##ABBREV(const TYPE *p)               \
  48 {                                               \
  49     return (struct unaligned_##ABBREV *) p;     \
  50 }                                               \
  51                                                 \
  52 static inline TYPE                              \
  53 get_unaligned_##ABBREV(const TYPE *p)           \
  54 {                                               \
  55     return unaligned_##ABBREV(p)->x;            \
  56 }                                               \
  57                                                 \
  58 static inline void                              \
  59 put_unaligned_##ABBREV(TYPE *p, TYPE x)         \
  60 {                                               \
  61     unaligned_##ABBREV(p)->x = x;               \
  62 }
  63
  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. */
  67
  68 GCC_UNALIGNED_ACCESSORS(ovs_be16, be16);
  69 GCC_UNALIGNED_ACCESSORS(ovs_be32, be32);
  70 GCC_UNALIGNED_ACCESSORS(ovs_be64, be64);
  71 #else
  72 /* Generic implementations. */
  73
  74 static inline uint16_t get_unaligned_u16(const uint16_t *p_)
  75 {
  76     const uint8_t *p = (const uint8_t *) p_;
  77     return ntohs((p[0] << 8) | p[1]);
  78 }
  79
  80 static inline void put_unaligned_u16(uint16_t *p_, uint16_t x_)
  81 {
  82     uint8_t *p = (uint8_t *) p_;
  83     uint16_t x = ntohs(x_);
  84
  85     p[0] = x >> 8;
  86     p[1] = x;
  87 }
  88
  89 static inline uint32_t get_unaligned_u32(const uint32_t *p_)
  90 {
  91     const uint8_t *p = (const uint8_t *) p_;
  92     return ntohl((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
  93 }
  94
  95 static inline void put_unaligned_u32(uint32_t *p_, uint32_t x_)
  96 {
  97     uint8_t *p = (uint8_t *) p_;
  98     uint32_t x = ntohl(x_);
  99
 100     p[0] = x >> 24;
 101     p[1] = x >> 16;
 102     p[2] = x >> 8;
 103     p[3] = x;
 104 }
 105
 106 static inline uint64_t get_unaligned_u64__(const uint64_t *p_)
 107 {
 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)
 113                   | (p[4] << 24)
 114                   | (p[5] << 16)
 115                   | (p[6] << 8)
 116                   | p[7]);
 117 }
 118
 119 static inline void put_unaligned_u64__(uint64_t *p_, uint64_t x_)
 120 {
 121     uint8_t *p = (uint8_t *) p_;
 122     uint64_t x = ntohll(x_);
 123
 124     p[0] = x >> 56;
 125     p[1] = x >> 48;
 126     p[2] = x >> 40;
 127     p[3] = x >> 32;
 128     p[4] = x >> 24;
 129     p[5] = x >> 16;
 130     p[6] = x >> 8;
 131     p[7] = x;
 132 }
 133
 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
 136  * accessors. */
 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
 143 #endif
 144
 145 /* uint64_t get_unaligned_u64(uint64_t *p);
 146  *
 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
 151  * long int".
 152  *
 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.
 156  *
 157  * Below, "sizeof (*(P) % 1)" verifies that *P has an integer type, since
 158  * operands to % must be integers.
 159  */
 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)))
 165
 166 /* Stores 'x' at possibly misaligned address 'p'.
 167  *
 168  * put_unaligned_u64() could be overloaded in the same way as
 169  * get_unaligned_u64(), but so far it has not proven necessary.
 170  */
 171 static inline void
 172 put_unaligned_u64(uint64_t *p, uint64_t x)
 173 {
 174     put_unaligned_u64__(p, x);
 175 }
 176 \f
 177 /* Returns the value in 'x'. */
 178 static inline uint64_t
 179 get_32aligned_u64(const ovs_32aligned_u64 *x)
 180 {
 181     return ((uint64_t) x->hi << 32) | x->lo;
 182 }
 183
 184 /* Stores 'value' in 'x'. */
 185 static inline void
 186 put_32aligned_u64(ovs_32aligned_u64 *x, uint64_t value)
 187 {
 188     x->hi = value >> 32;
 189     x->lo = value;
 190 }
 191
 192 #ifndef __CHECKER__
 193 /* Returns the value of 'x'. */
 194 static inline ovs_be64
 195 get_32aligned_be64(const ovs_32aligned_be64 *x)
 196 {
 197 #ifdef WORDS_BIGENDIAN
 198     return ((ovs_be64) x->hi << 32) | x->lo;
 199 #else
 200     return ((ovs_be64) x->lo << 32) | x->hi;
 201 #endif
 202 }
 203
 204 /* Stores network byte order 'value' into 'x'. */
 205 static inline void
 206 put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value)
 207 {
 208 #if WORDS_BIGENDIAN
 209     x->hi = value >> 32;
 210     x->lo = value;
 211 #else
 212     x->hi = value;
 213     x->lo = value >> 32;
 214 #endif
 215 }
 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);
 221 #endif
 222
 223 #endif /* unaligned.h */