Parser: rewrite the iterate_string_chunks function with new chunk code

The new get_string_chunk function allows us to merge the chunked and
non-chunked versions into one single code path. Not only will this share
code with the chunk functions (if the user is using them), there is an
actual reduction in code size after this change.

Before, the function was 0x1d8 bytes in size on x86-64 (-march=skylake)
and 0x17b bytes for x86 (-march=silvermont -miamcu). After, the
combination of the the new iteration function and get_string_chunk is,
respectively, 0x193 and 0x157 bytes, a reduction of 69 and 36 bytes.

Signed-off-by: Thiago Macieira <[email protected]>

Author: thiagomacieira

src/cborparser.c

@@ -1107,60 +1107,34 @@ static CborError iterate_string_chunks(const CborValue *value, char *buffer, siz
 {
     cbor_assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
 
-    size_t total;
     CborError err;
-    const uint8_t *ptr = value->ptr;
-    if (cbor_value_is_length_known(value)) {
-        /* easy case: fixed length */
-        err = extract_length(value->parser, &ptr, &total);
-        if (err)
-            return err;
-        if (total > (size_t)(value->parser->end - ptr))
-            return CborErrorUnexpectedEOF;
-        if (total <= *buflen)
-            *result = !!func(buffer, ptr, total);
-        else
-            *result = false;
-        ptr += total;
-    } else {
-        /* chunked */
-        ++ptr;
-        total = 0;
-        *result = true;
-        while (true) {
-            size_t chunkLen;
-            size_t newTotal;
-
-            if (ptr == value->parser->end)
-                return CborErrorUnexpectedEOF;
-
-            if (*ptr == (uint8_t)BreakByte) {
-                ++ptr;
-                break;
-            }
-
-            /* is this the right type? */
-            if ((*ptr & MajorTypeMask) != value->type)
-                return CborErrorIllegalType;
+    CborValue tmp;
+    size_t total = 0;
+    const void *ptr;
 
-            err = extract_length(value->parser, &ptr, &chunkLen);
-            if (err)
-                return err;
+    if (!next)
+        next = &tmp;
+    *next = *value;
+    *result = true;
 
-            if (unlikely(add_check_overflow(total, chunkLen, &newTotal)))
-                return CborErrorDataTooLarge;
+    while (1) {
+        size_t newTotal;
+        size_t chunkLen;
+        err = get_string_chunk(next, &ptr, &chunkLen);
+        if (err)
+            return err;
+        if (!ptr)
+            break;
 
-            if (chunkLen > (size_t)(value->parser->end - ptr))
-                return CborErrorUnexpectedEOF;
+        if (unlikely(add_check_overflow(total, chunkLen, &newTotal)))
+            return CborErrorDataTooLarge;
 
-            if (*result && *buflen >= newTotal)
-                *result = !!func(buffer + total, ptr, chunkLen);
-            else
-                *result = false;
+        if (*result && *buflen >= newTotal)
+            *result = !!func(buffer + total, (const uint8_t *)ptr, chunkLen);
+        else
+            *result = false;
 
-            ptr += chunkLen;
-            total = newTotal;
-        }
+        total = newTotal;
     }
 
     /* is there enough room for the ending NUL byte? */
@@ -1169,12 +1143,6 @@ static CborError iterate_string_chunks(const CborValue *value, char *buffer, siz
         *result = !!func(buffer + total, nul, 1);
     }
     *buflen = total;
-
-    if (next) {
-        *next = *value;
-        next->ptr = ptr;
-        return preparse_next_value(next);
-    }
     return CborNoError;
 }