X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fhelper%2Fbinarybuffer.h;h=a8343c2aa091a80a8715d898f383fb265c7a3f0c;hp=3fbfea49efa7ea271ee96216dd180e4fad6ca165;hb=d0e763ac7ef6aa17b17bd00ccdfbccfb4eacda69;hpb=08d4411b59dd8bd0e7d8009003b71d23acbf6eee

diff --git a/src/helper/binarybuffer.h b/src/helper/binarybuffer.h
index 3fbfea49ef..a8343c2aa0 100644
--- a/src/helper/binarybuffer.h
+++ b/src/helper/binarybuffer.h
@@ -16,9 +16,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef BINARYBUFFER_H
@@ -39,10 +37,10 @@
  * @param num The number of bits from @c value to copy (1-32).
  * @param value Up to 32 bits that will be copied to _buffer.
  */
-static inline void buf_set_u32(void *_buffer,
+static inline void buf_set_u32(uint8_t *_buffer,
 	unsigned first, unsigned num, uint32_t value)
 {
-	uint8_t *buffer = (uint8_t *)_buffer;
+	uint8_t *buffer = _buffer;
 
 	if ((num == 32) && (first == 0)) {
 		buffer[3] = (value >> 24) & 0xff;
@@ -58,6 +56,45 @@ static inline void buf_set_u32(void *_buffer,
 		}
 	}
 }
+
+/**
+ * Sets @c num bits in @c _buffer, starting at the @c first bit,
+ * using the bits in @c value.  This routine fast-paths writes
+ * of little-endian, byte-aligned, 64-bit words.
+ * @param _buffer The buffer whose bits will be set.
+ * @param first The bit offset in @c _buffer to start writing (0-63).
+ * @param num The number of bits from @c value to copy (1-64).
+ * @param value Up to 64 bits that will be copied to _buffer.
+ */
+static inline void buf_set_u64(uint8_t *_buffer,
+	unsigned first, unsigned num, uint64_t value)
+{
+	uint8_t *buffer = _buffer;
+
+	if ((num == 32) && (first == 0)) {
+		buffer[3] = (value >> 24) & 0xff;
+		buffer[2] = (value >> 16) & 0xff;
+		buffer[1] = (value >> 8) & 0xff;
+		buffer[0] = (value >> 0) & 0xff;
+	} else if ((num == 64) && (first == 0)) {
+		buffer[7] = (value >> 56) & 0xff;
+		buffer[6] = (value >> 48) & 0xff;
+		buffer[5] = (value >> 40) & 0xff;
+		buffer[4] = (value >> 32) & 0xff;
+		buffer[3] = (value >> 24) & 0xff;
+		buffer[2] = (value >> 16) & 0xff;
+		buffer[1] = (value >> 8) & 0xff;
+		buffer[0] = (value >> 0) & 0xff;
+	} else {
+		for (unsigned i = first; i < first + num; i++) {
+			if (((value >> (i - first)) & 1) == 1)
+				buffer[i / 8] |= 1 << (i % 8);
+			else
+				buffer[i / 8] &= ~(1 << (i % 8));
+		}
+	}
+}
+
 /**
  * Retrieves @c num bits from @c _buffer, starting at the @c first bit,
  * returning the bits in a 32-bit word.  This routine fast-paths reads
@@ -67,10 +104,10 @@ static inline void buf_set_u32(void *_buffer,
  * @param num The number of bits from @c _buffer to read (1-32).
  * @returns Up to 32-bits that were read from @c _buffer.
  */
-static inline uint32_t buf_get_u32(const void *_buffer,
+static inline uint32_t buf_get_u32(const uint8_t *_buffer,
 	unsigned first, unsigned num)
 {
-	uint8_t *buffer = (uint8_t *)_buffer;
+	const uint8_t *buffer = _buffer;
 
 	if ((num == 32) && (first == 0)) {
 		return (((uint32_t)buffer[3]) << 24) |
@@ -87,6 +124,45 @@ static inline uint32_t buf_get_u32(const void *_buffer,
 	}
 }
 
+/**
+ * Retrieves @c num bits from @c _buffer, starting at the @c first bit,
+ * returning the bits in a 64-bit word.  This routine fast-paths reads
+ * of little-endian, byte-aligned, 64-bit words.
+ * @param _buffer The buffer whose bits will be read.
+ * @param first The bit offset in @c _buffer to start reading (0-63).
+ * @param num The number of bits from @c _buffer to read (1-64).
+ * @returns Up to 64-bits that were read from @c _buffer.
+ */
+static inline uint64_t buf_get_u64(const uint8_t *_buffer,
+	unsigned first, unsigned num)
+{
+	const uint8_t *buffer = _buffer;
+
+	if ((num == 32) && (first == 0)) {
+		return 0 + ((((uint32_t)buffer[3]) << 24) |   /* Note - zero plus is to avoid a checkpatch bug */
+				(((uint32_t)buffer[2]) << 16) |
+				(((uint32_t)buffer[1]) << 8)  |
+				(((uint32_t)buffer[0]) << 0));
+	} else if ((num == 64) && (first == 0)) {
+		return 0 + ((((uint64_t)buffer[7]) << 56) |   /* Note - zero plus is to avoid a checkpatch bug */
+				(((uint64_t)buffer[6]) << 48) |
+				(((uint64_t)buffer[5]) << 40) |
+				(((uint64_t)buffer[4]) << 32) |
+				(((uint64_t)buffer[3]) << 24) |
+				(((uint64_t)buffer[2]) << 16) |
+				(((uint64_t)buffer[1]) << 8)  |
+				(((uint64_t)buffer[0]) << 0));
+	} else {
+		uint64_t result = 0;
+		for (unsigned i = first; i < first + num; i++) {
+			if (((buffer[i / 8] >> (i % 8)) & 1) == 1)
+				result = result | ((uint64_t)1 << (uint64_t)(i - first));
+		}
+		return result;
+	}
+}
+
+
 /**
  * Inverts the ordering of bits inside a 32-bit word (e.g. 31..0 -> 0..31).
  * This routine can be used to flip smaller data types by using smaller
@@ -160,5 +236,6 @@ void bit_copy_discard(struct bit_copy_queue *q);
  * used in ti-icdi driver and gdb server */
 int unhexify(char *bin, const char *hex, int count);
 int hexify(char *hex, const char *bin, int count, int out_maxlen);
+void buffer_shr(void *_buf, unsigned buf_len, unsigned count);
 
 #endif /* BINARYBUFFER_H */