OpenOCD
binarybuffer.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
3 /***************************************************************************
4  * Copyright (C) 2004, 2005 by Dominic Rath *
5  * Dominic.Rath@gmx.de *
6  * *
7  * Copyright (C) 2007,2008 Øyvind Harboe *
8  * oyvind.harboe@zylin.com *
9  ***************************************************************************/
10 
11 #ifndef OPENOCD_HELPER_BINARYBUFFER_H
12 #define OPENOCD_HELPER_BINARYBUFFER_H
13 
14 #include "list.h"
15 
30 static inline void buf_set_u32(uint8_t *_buffer,
31  unsigned first, unsigned num, uint32_t value)
32 {
33  uint8_t *buffer = _buffer;
34 
35  if ((num == 32) && (first == 0)) {
36  buffer[3] = (value >> 24) & 0xff;
37  buffer[2] = (value >> 16) & 0xff;
38  buffer[1] = (value >> 8) & 0xff;
39  buffer[0] = (value >> 0) & 0xff;
40  } else {
41  for (unsigned i = first; i < first + num; i++) {
42  if (((value >> (i - first)) & 1) == 1)
43  buffer[i / 8] |= 1 << (i % 8);
44  else
45  buffer[i / 8] &= ~(1 << (i % 8));
46  }
47  }
48 }
49 
60 static inline void buf_set_u64(uint8_t *_buffer,
61  unsigned first, unsigned num, uint64_t value)
62 {
63  uint8_t *buffer = _buffer;
64 
65  if ((num == 32) && (first == 0)) {
66  buffer[3] = (value >> 24) & 0xff;
67  buffer[2] = (value >> 16) & 0xff;
68  buffer[1] = (value >> 8) & 0xff;
69  buffer[0] = (value >> 0) & 0xff;
70  } else if ((num == 64) && (first == 0)) {
71  buffer[7] = (value >> 56) & 0xff;
72  buffer[6] = (value >> 48) & 0xff;
73  buffer[5] = (value >> 40) & 0xff;
74  buffer[4] = (value >> 32) & 0xff;
75  buffer[3] = (value >> 24) & 0xff;
76  buffer[2] = (value >> 16) & 0xff;
77  buffer[1] = (value >> 8) & 0xff;
78  buffer[0] = (value >> 0) & 0xff;
79  } else {
80  for (unsigned i = first; i < first + num; i++) {
81  if (((value >> (i - first)) & 1) == 1)
82  buffer[i / 8] |= 1 << (i % 8);
83  else
84  buffer[i / 8] &= ~(1 << (i % 8));
85  }
86  }
87 }
88 
98 static inline uint32_t buf_get_u32(const uint8_t *_buffer,
99  unsigned first, unsigned num)
100 {
101  const uint8_t *buffer = _buffer;
102 
103  if ((num == 32) && (first == 0)) {
104  return (((uint32_t)buffer[3]) << 24) |
105  (((uint32_t)buffer[2]) << 16) |
106  (((uint32_t)buffer[1]) << 8) |
107  (((uint32_t)buffer[0]) << 0);
108  } else {
109  uint32_t result = 0;
110  for (unsigned i = first; i < first + num; i++) {
111  if (((buffer[i / 8] >> (i % 8)) & 1) == 1)
112  result |= 1U << (i - first);
113  }
114  return result;
115  }
116 }
117 
127 static inline uint64_t buf_get_u64(const uint8_t *_buffer,
128  unsigned first, unsigned num)
129 {
130  const uint8_t *buffer = _buffer;
131 
132  if ((num == 32) && (first == 0)) {
133  return 0 + ((((uint32_t)buffer[3]) << 24) | /* Note - zero plus is to avoid a checkpatch bug */
134  (((uint32_t)buffer[2]) << 16) |
135  (((uint32_t)buffer[1]) << 8) |
136  (((uint32_t)buffer[0]) << 0));
137  } else if ((num == 64) && (first == 0)) {
138  return 0 + ((((uint64_t)buffer[7]) << 56) | /* Note - zero plus is to avoid a checkpatch bug */
139  (((uint64_t)buffer[6]) << 48) |
140  (((uint64_t)buffer[5]) << 40) |
141  (((uint64_t)buffer[4]) << 32) |
142  (((uint64_t)buffer[3]) << 24) |
143  (((uint64_t)buffer[2]) << 16) |
144  (((uint64_t)buffer[1]) << 8) |
145  (((uint64_t)buffer[0]) << 0));
146  } else {
147  uint64_t result = 0;
148  for (unsigned i = first; i < first + num; i++) {
149  if (((buffer[i / 8] >> (i % 8)) & 1) == 1)
150  result = result | ((uint64_t)1 << (uint64_t)(i - first));
151  }
152  return result;
153  }
154 }
155 
156 
165 uint32_t flip_u32(uint32_t value, unsigned width);
166 
167 bool buf_cmp(const void *buf1, const void *buf2, unsigned size);
168 bool buf_cmp_mask(const void *buf1, const void *buf2,
169  const void *mask, unsigned size);
170 
178 void *buf_cpy(const void *from, void *to, unsigned size);
179 
186 void *buf_set_ones(void *buf, unsigned size);
187 
188 void *buf_set_buf(const void *src, unsigned src_start,
189  void *dst, unsigned dst_start, unsigned len);
190 
191 int str_to_buf(const char *str, unsigned len,
192  void *bin_buf, unsigned buf_size, unsigned radix);
193 char *buf_to_hex_str(const void *buf, unsigned size);
194 
195 /* read a uint32_t from a buffer in target memory endianness */
196 static inline uint32_t fast_target_buffer_get_u32(const void *p, bool le)
197 {
198  return le ? le_to_h_u32(p) : be_to_h_u32(p);
199 }
200 
201 static inline void bit_copy(uint8_t *dst, unsigned dst_offset, const uint8_t *src,
202  unsigned src_offset, unsigned bit_count)
203 {
204  buf_set_buf(src, src_offset, dst, dst_offset, bit_count);
205 }
206 
208  struct list_head list;
209 };
210 
212  uint8_t *dst;
213  unsigned dst_offset;
214  const uint8_t *src;
215  unsigned src_offset;
216  unsigned bit_count;
217  struct list_head list;
218 };
219 
220 void bit_copy_queue_init(struct bit_copy_queue *q);
221 int bit_copy_queued(struct bit_copy_queue *q, uint8_t *dst, unsigned dst_offset, const uint8_t *src,
222  unsigned src_offset, unsigned bit_count);
223 void bit_copy_execute(struct bit_copy_queue *q);
224 void bit_copy_discard(struct bit_copy_queue *q);
225 
226 /* functions to convert to/from hex encoded buffer
227  * used in ti-icdi driver and gdb server */
228 size_t unhexify(uint8_t *bin, const char *hex, size_t count);
229 size_t hexify(char *hex, const uint8_t *bin, size_t count, size_t out_maxlen);
230 void buffer_shr(void *_buf, unsigned buf_len, unsigned count);
231 
232 #endif /* OPENOCD_HELPER_BINARYBUFFER_H */
uint32_t flip_u32(uint32_t value, unsigned width)
Inverts the ordering of bits inside a 32-bit word (e.g.
void bit_copy_queue_init(struct bit_copy_queue *q)
Definition: binarybuffer.c:299
void * buf_set_ones(void *buf, unsigned size)
Set the contents of buf with count bits, all set to 1.
Definition: binarybuffer.c:106
void bit_copy_discard(struct bit_copy_queue *q)
Definition: binarybuffer.c:332
int bit_copy_queued(struct bit_copy_queue *q, uint8_t *dst, unsigned dst_offset, const uint8_t *src, unsigned src_offset, unsigned bit_count)
Definition: binarybuffer.c:304
void bit_copy_execute(struct bit_copy_queue *q)
Definition: binarybuffer.c:321
static void bit_copy(uint8_t *dst, unsigned dst_offset, const uint8_t *src, unsigned src_offset, unsigned bit_count)
Definition: binarybuffer.h:201
bool buf_cmp_mask(const void *buf1, const void *buf2, const void *mask, unsigned size)
Definition: binarybuffer.c:87
bool buf_cmp(const void *buf1, const void *buf2, unsigned size)
Definition: binarybuffer.c:70
static void buf_set_u64(uint8_t *_buffer, unsigned first, unsigned num, uint64_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:60
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
Definition: binarybuffer.h:98
void buffer_shr(void *_buf, unsigned buf_len, unsigned count)
Definition: binarybuffer.c:410
int str_to_buf(const char *str, unsigned len, void *bin_buf, unsigned buf_size, unsigned radix)
Definition: binarybuffer.c:233
static void buf_set_u32(uint8_t *_buffer, unsigned first, unsigned num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:30
static uint32_t fast_target_buffer_get_u32(const void *p, bool le)
Definition: binarybuffer.h:196
static uint64_t buf_get_u64(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 64-bit word.
Definition: binarybuffer.h:127
void * buf_set_buf(const void *src, unsigned src_start, void *dst, unsigned dst_start, unsigned len)
Definition: binarybuffer.c:121
size_t unhexify(uint8_t *bin, const char *hex, size_t count)
Convert a string of hexadecimal pairs into its binary representation.
Definition: binarybuffer.c:354
size_t hexify(char *hex, const uint8_t *bin, size_t count, size_t out_maxlen)
Convert binary data into a string of hexadecimal pairs.
Definition: binarybuffer.c:392
char * buf_to_hex_str(const void *buf, unsigned size)
Definition: binarybuffer.c:192
void * buf_cpy(const void *from, void *to, unsigned size)
Copies size bits out of from and into to.
Definition: binarybuffer.c:43
unsigned short width
Definition: embeddedice.c:47
int mask
Definition: esirisc.c:1698
size_t size
Size of the control block search area.
Definition: rtt/rtt.c:30
Definition: binarybuffer.h:211
uint8_t * dst
Definition: binarybuffer.h:212
unsigned src_offset
Definition: binarybuffer.h:215
unsigned dst_offset
Definition: binarybuffer.h:213
struct list_head list
Definition: binarybuffer.h:217
unsigned bit_count
Definition: binarybuffer.h:216
const uint8_t * src
Definition: binarybuffer.h:214
struct list_head list
Definition: binarybuffer.h:208
Definition: list.h:26
static uint32_t be_to_h_u32(const uint8_t *buf)
Definition: types.h:139
static uint32_t le_to_h_u32(const uint8_t *buf)
Definition: types.h:112
uint8_t count[4]
Definition: vdebug.c:22