pintos-os.org Git - openvswitch/blob - 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 #ifndef __CHECKER__
 160 /* Returns the value of 'x'. */
 161 static inline ovs_be64
 162 get_32aligned_be64(const ovs_32aligned_be64 *x)
 163 {
 164 #ifdef WORDS_BIGENDIAN
 165         return ((ovs_be64) x->hi << 32) | x->lo;
 166 #else
 167         return ((ovs_be64) x->lo << 32) | x->hi;
 168 #endif
 169 }
 170
 171 /* Stores network byte order 'value' into 'x'. */
 172 static inline void
 173 put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value)
 174 {
 175 #if WORDS_BIGENDIAN
 176         x->hi = value >> 32;
 177         x->lo = value;
 178 #else
 179     x->hi = value;
 180     x->lo = value >> 32;
 181 #endif
 182 }
 183 #else  /* __CHECKER__ */
 184 /* Making sparse happy with these functions also makes them unreadable, so
 185  * don't bother to show it their implementations. */
 186 ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *);
 187 void put_32aligned_be64(ovs_32aligned_be64 *, ovs_be64);
 188 #endif
 189
 190 #endif /* unaligned.h */