clang: fix warning w/assert so that clang knows that there will be no division by...

[openocd.git] / src / helper / binarybuffer.c

diff --git a/src/helper/binarybuffer.c b/src/helper/binarybuffer.c
index 53ad4d395da899ea33de8d40a27c7777749cc070..5732689c01e95fd8ff1033e45427a5bc0417d821 100644 (file)
--- a/src/helper/binarybuffer.c
+++ b/src/helper/binarybuffer.c
@@ -27,7 +27,7 @@
 #include "log.h"
 #include "binarybuffer.h"
 
-const unsigned char bit_reverse_table256[] =
+static const unsigned char bit_reverse_table256[] =
 {
   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
@@ -54,7 +54,7 @@ void* buf_cpy(const void *from, void *_to, unsigned size)
                return NULL;
 
        // copy entire buffer
-       memcpy(_to, from, CEIL(size, 8));
+       memcpy(_to, from, DIV_ROUND_UP(size, 8));
 
        /* mask out bits that don't belong to the buffer */
        unsigned trailing_bits = size % 8;
@@ -133,19 +133,48 @@ void* buf_set_buf(const void *_src, unsigned src_start,
 {
        const uint8_t *src = _src;
        uint8_t *dst = _dst;
+       unsigned  i,sb,db,sq,dq, lb,lq;
+
+       sb = src_start / 8;
+       db = dst_start / 8;
+       sq = src_start % 8;
+       dq = dst_start % 8;
+       lb = len / 8;
+       lq = len % 8;
+
+       src += sb;
+       dst += db;
+
+       /* check if both buffers are on byte boundary and
+        * len is a multiple of 8bit so we can simple copy
+        * the buffer */
+       if ( (sq == 0) && (dq == 0) &&  (lq == 0) )
+       {
+               for (i = 0; i < lb; i++)
+                       *dst++ = *src++;
+               return (uint8_t*)_dst;
+       }
 
-       unsigned src_idx = src_start, dst_idx = dst_start;
-       for (unsigned i = 0; i < len; i++)
+       /* fallback to slow bit copy */
+       for (i = 0; i < len; i++)
        {
-               if (((src[src_idx / 8] >> (src_idx % 8)) & 1) == 1)
-                       dst[dst_idx / 8] |= 1 << (dst_idx % 8);
+               if (((*src >> (sq&7)) & 1) == 1)
+                       *dst |= 1 << (dq&7);
                else
-                       dst[dst_idx / 8] &= ~(1 << (dst_idx % 8));
-               dst_idx++;
-               src_idx++;
+                       *dst &= ~(1 << (dq&7));
+               if ( sq++ == 7 )
+               {
+                       sq = 0;
+                       src++;
+               }
+               if ( dq++ == 7 )
+               {
+                       dq = 0;
+                       dst++;
+               }
        }
 
-       return dst;
+       return (uint8_t*)_dst;
 }
 
 uint32_t flip_u32(uint32_t value, unsigned int num)
@@ -161,7 +190,7 @@ uint32_t flip_u32(uint32_t value, unsigned int num)
        return c;
 }
 
-int ceil_f_to_u32(float x)
+static int ceil_f_to_u32(float x)
 {
        if (x < 0)      /* return zero for negative numbers */
                return 0;
@@ -191,11 +220,11 @@ char* buf_to_str(const void *_buf, unsigned buf_len, unsigned radix)
                return NULL;
        }
 
-       unsigned str_len = ceil_f_to_u32(CEIL(buf_len, 8) * factor);
+       unsigned str_len = ceil_f_to_u32(DIV_ROUND_UP(buf_len, 8) * factor);
        char *str = calloc(str_len + 1, 1);
 
        const uint8_t *buf = _buf;
-       int b256_len = CEIL(buf_len, 8);
+       int b256_len = DIV_ROUND_UP(buf_len, 8);
        for (int i = b256_len - 1; i >= 0; i--)
        {
                uint32_t tmp = buf[i];
@@ -300,7 +329,7 @@ int str_to_buf(const char *str, unsigned str_len,
        }
 
        uint8_t *buf = _buf;
-       for (unsigned j = 0; j < CEIL(buf_len, 8); j++)
+       for (unsigned j = 0; j < DIV_ROUND_UP(buf_len, 8); j++)
        {
                if (j < b256_len)
                        buf[j] = b256_buf[j];