Debian Codegraph @

libdrgn/serialize.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <assert.h>
5 #include <endian.h>
6
7 #include "serialize.h"
8
9 static inline uint8_t copy_bits_step(const uint8_t *s, unsigned int src_bit_offset,
10 unsigned int bit_size,
11 unsigned int dst_bit_offset, bool lsb0)
12 {
13 uint8_t result;
14 if (lsb0) {
15 result = s[0] >> src_bit_offset;
16 if (bit_size > 8 - src_bit_offset)
17 result |= s[1] << (8 - src_bit_offset);
18 result <<= dst_bit_offset;
19 } else {
20 result = s[0] << src_bit_offset;
21 if (bit_size > 8 - src_bit_offset)
22 result |= s[1] >> (8 - src_bit_offset);
23 result >>= dst_bit_offset;
24 }
25 return result;
26 }
27
28 void copy_bits(void *dst, unsigned int dst_bit_offset, const void *src,
29 unsigned int src_bit_offset, uint64_t bit_size, bool lsb0)
30 {
31 assert(dst_bit_offset < 8);
32 assert(src_bit_offset < 8);
33
34 if (bit_size == 0)
35 return;
36
37 uint8_t *d = dst;
38 const uint8_t *s = src;
39 uint64_t dst_last_bit = dst_bit_offset + bit_size - 1;
40 uint8_t dst_first_mask = copy_bits_first_mask(dst_bit_offset, lsb0);
41 uint8_t dst_last_mask = copy_bits_last_mask(dst_last_bit, lsb0);
42
43 if (dst_bit_offset == src_bit_offset) {
44 /*
45 * In the common case that the source and destination have the
46 * same offset, we can use memcpy(), preserving bits at the
47 * start and/or end if necessary.
48 */
49 uint8_t first_byte = d[0];
50 uint8_t last_byte = d[dst_last_bit / 8];
51 memcpy(d, s, dst_last_bit / 8 + 1);
52 if (dst_bit_offset != 0) {
53 d[0] = ((first_byte & ~dst_first_mask)
54 | (d[0] & dst_first_mask));
55 }
56 if (dst_last_bit % 8 != 7) {
57 d[dst_last_bit / 8] = ((last_byte & ~dst_last_mask)
58 | (d[dst_last_bit / 8] & dst_last_mask));
59 }
60 } else if (bit_size <= 8 - dst_bit_offset) {
61 /* Destination is only one byte. */
62 uint8_t dst_mask = dst_first_mask & dst_last_mask;
63 d[0] = ((d[0] & ~dst_mask)
64 | (copy_bits_step(&s[0], src_bit_offset, bit_size,
65 dst_bit_offset, lsb0) & dst_mask));
66 } else {
67 /* Destination is two or more bytes. */
68 d[0] = ((d[0] & ~dst_first_mask)
69 | (copy_bits_step(&s[0], src_bit_offset,
70 8 - dst_bit_offset, dst_bit_offset,
71 lsb0) & dst_first_mask));
72 src_bit_offset += 8 - dst_bit_offset;
73 size_t si = src_bit_offset / 8;
74 src_bit_offset %= 8;
75 size_t di = 1;
76 while (di < dst_last_bit / 8) {
77 d[di] = copy_bits_step(&s[si], src_bit_offset, 8, 0,
78 lsb0);
79 di++;
80 si++;
81 }
82 d[di] = ((d[di] & ~dst_last_mask)
83 | (copy_bits_step(&s[si], src_bit_offset,
84 dst_last_bit % 8 + 1, 0, lsb0)
85 & dst_last_mask));
86 }
87 }
88
89 void serialize_bits(void *buf, uint64_t bit_offset, uint64_t uvalue,
90 uint8_t bit_size, bool little_endian)
91 {
92 uint8_t *p;
93 size_t bits, size;
94 unsigned char tmp[9];
95 uint8_t first_mask, last_mask;
96
97 assert(bit_size > 0);
98 assert(bit_size <= 64);
99
100 p = (uint8_t *)buf + bit_offset / 8;
101 bit_offset %= 8;
102 bits = bit_offset + bit_size;
103 size = (bits + 7) / 8;
104 if (little_endian) {
105 if (size > sizeof(uvalue))
106 tmp[8] = uvalue >> (64 - bit_offset);
107 uvalue = htole64(uvalue << bit_offset);
108 memcpy(tmp, &uvalue, sizeof(uvalue));
109
110 /* bit_offset least significant bits. */
111 first_mask = (1 << bit_offset) - 1;
112 /* 8 - (bit_offset + bit_size) % 8 most significant bits. */
113 last_mask = 0xff00 >> -bits % 8;
114 } else {
115 unsigned int shift;
116
117 shift = -bits % 8;
118 if (size > sizeof(uvalue)) {
119 tmp[0] = uvalue >> (64 - shift);
120 uvalue = htobe64(uvalue << shift);
121 memcpy(&tmp[1], &uvalue, sizeof(uvalue));
122 } else {
123 uvalue = htobe64(uvalue << (64 - bits));
124 memcpy(&tmp[0], &uvalue, sizeof(uvalue));
125 }
126
127 /* bit_offset most significant bits. */
128 first_mask = 0xff00 >> bit_offset;
129 /* 8 - (bit_offset + bit_size) % 8 least significant bits. */
130 last_mask = (1 << shift) - 1;
131 }
132
133 if (size == 1) {
134 p[0] = (p[0] & (first_mask | last_mask)) | tmp[0];
135 } else {
136 p[0] = (p[0] & first_mask) | tmp[0];
137 memcpy(p + 1, tmp + 1, size - 2);
138 p[size - 1] = (p[size - 1] & last_mask) | tmp[size - 1];
139 }
140 }
141
142 uint64_t deserialize_bits(const void *buf, uint64_t bit_offset,
143 uint8_t bit_size, bool little_endian)
144 {
145 const uint8_t *p;
146 size_t bits, size;
147 uint64_t ret = 0;
148
149 assert(bit_size > 0);
150 assert(bit_size <= 64);
151
152 p = (const uint8_t *)buf + bit_offset / 8;
153 bit_offset %= 8;
154 bits = bit_offset + bit_size;
155 size = (bits + 7) / 8;
156 if (little_endian) {
157 memcpy(&ret, p, min(size, sizeof(ret)));
158 ret = le64toh(ret) >> bit_offset;
159 if (size > sizeof(ret))
160 ret |= (uint64_t)p[8] << (64 - bit_offset);
161 } else {
162 unsigned int shift;
163
164 if (size > sizeof(ret))
165 memcpy(&ret, &p[1], sizeof(ret));
166 else
167 memcpy((char *)(&ret + 1) - size, p, size);
168 shift = -bits % 8;
169 ret = be64toh(ret) >> shift;
170 if (size > sizeof(ret))
171 ret |= (uint64_t)p[0] << (64 - shift);
172 }
173 return truncate_unsigned(ret, bit_size);
174 }