wimlib.net Git - wimlib/blob - include/wimlib/unaligned.h

   1 /*
   2  * unaligned.h - inline functions for unaligned memory accesses
   3  *
   4  * Copyright 2022 Eric Biggers
   5  *
   6  * Permission is hereby granted, free of charge, to any person
   7  * obtaining a copy of this software and associated documentation
   8  * files (the "Software"), to deal in the Software without
   9  * restriction, including without limitation the rights to use,
  10  * copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following
  13  * conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be
  16  * included in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  20  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  22  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25  * OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #ifndef _WIMLIB_UNALIGNED_H
  29 #define _WIMLIB_UNALIGNED_H
  30
  31 #include <string.h>
  32
  33 #include "wimlib/compiler.h"
  34 #include "wimlib/endianness.h"
  35 #include "wimlib/types.h"
  36
  37 #define DEFINE_UNALIGNED_TYPE(type)                             \
  38 static forceinline type                                         \
  39 load_##type##_unaligned(const void *p)                          \
  40 {                                                               \
  41         type v;                                                 \
  42         memcpy(&v, p, sizeof(v));                               \
  43         return v;                                               \
  44 }                                                               \
  45                                                                 \
  46 static forceinline void                                         \
  47 store_##type##_unaligned(type v, void *p)                       \
  48 {                                                               \
  49         memcpy(p, &v, sizeof(v));                               \
  50 }
  51
  52 DEFINE_UNALIGNED_TYPE(u16);
  53 DEFINE_UNALIGNED_TYPE(u32);
  54 DEFINE_UNALIGNED_TYPE(u64);
  55 DEFINE_UNALIGNED_TYPE(le16);
  56 DEFINE_UNALIGNED_TYPE(le32);
  57 DEFINE_UNALIGNED_TYPE(le64);
  58 DEFINE_UNALIGNED_TYPE(be16);
  59 DEFINE_UNALIGNED_TYPE(be32);
  60 DEFINE_UNALIGNED_TYPE(be64);
  61 DEFINE_UNALIGNED_TYPE(size_t);
  62 DEFINE_UNALIGNED_TYPE(machine_word_t);
  63
  64 #define load_word_unaligned     load_machine_word_t_unaligned
  65 #define store_word_unaligned    store_machine_word_t_unaligned
  66
  67 static forceinline u16
  68 get_unaligned_le16(const u8 *p)
  69 {
  70         if (UNALIGNED_ACCESS_IS_FAST)
  71                 return le16_to_cpu(load_le16_unaligned(p));
  72         else
  73                 return ((u16)p[1] << 8) | p[0];
  74 }
  75
  76 static forceinline u32
  77 get_unaligned_le32(const u8 *p)
  78 {
  79         if (UNALIGNED_ACCESS_IS_FAST)
  80                 return le32_to_cpu(load_le32_unaligned(p));
  81         else
  82                 return ((u32)p[3] << 24) | ((u32)p[2] << 16) |
  83                         ((u32)p[1] << 8) | p[0];
  84 }
  85
  86 static forceinline u32
  87 get_unaligned_be32(const u8 *p)
  88 {
  89         if (UNALIGNED_ACCESS_IS_FAST)
  90                 return be32_to_cpu(load_be32_unaligned(p));
  91         else
  92                 return ((u32)p[0] << 24) | ((u32)p[1] << 16) |
  93                         ((u32)p[2] << 8) | p[3];
  94 }
  95
  96 static forceinline void
  97 put_unaligned_le16(u16 v, u8 *p)
  98 {
  99         if (UNALIGNED_ACCESS_IS_FAST) {
 100                 store_le16_unaligned(cpu_to_le16(v), p);
 101         } else {
 102                 p[0] = (u8)(v >> 0);
 103                 p[1] = (u8)(v >> 8);
 104         }
 105 }
 106
 107 static forceinline void
 108 put_unaligned_le32(u32 v, u8 *p)
 109 {
 110         if (UNALIGNED_ACCESS_IS_FAST) {
 111                 store_le32_unaligned(cpu_to_le32(v), p);
 112         } else {
 113                 p[0] = (u8)(v >> 0);
 114                 p[1] = (u8)(v >> 8);
 115                 p[2] = (u8)(v >> 16);
 116                 p[3] = (u8)(v >> 24);
 117         }
 118 }
 119
 120 static forceinline void
 121 put_unaligned_be32(u32 v, u8 *p)
 122 {
 123         if (UNALIGNED_ACCESS_IS_FAST) {
 124                 store_be32_unaligned(cpu_to_be32(v), p);
 125         } else {
 126                 p[0] = (u8)(v >> 24);
 127                 p[1] = (u8)(v >> 16);
 128                 p[2] = (u8)(v >> 8);
 129                 p[3] = (u8)(v >> 0);
 130         }
 131 }
 132
 133 #endif /* _WIMLIB_UNALIGNED_H */