Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/base64.h	Lines:	82	84	97.6 %
Date:	2019-09-13 22:28:55	Branches:	89	143	62.2 %


#ifndef SRC_BASE64_H_
#define SRC_BASE64_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "util.h"

#include <cstddef>
#include <cstdint>

namespace node {
//// Base 64 ////
static inline constexpr size_t base64_encoded_size(size_t size) {
  return ((size + 2 - ((size + 2) % 3)) / 3 * 4);
}

// Doesn't check for padding at the end.  Can be 1-2 bytes over.
static inline size_t base64_decoded_size_fast(size_t size) {
  size_t remainder = size % 4;

  size = (size / 4) * 3;
  if (remainder) {
    if (size == 0 && remainder == 1) {
      // special case: 1-byte input cannot be decoded
      size = 0;
    } else {
      // non-padded input, add 1 or 2 extra bytes
      size += 1 + (remainder == 3);
    }
  }

  return size;
}

template <typename TypeName>
size_t base64_decoded_size(const TypeName* src, size_t size) {
  if (size == 0)
    return 0;

  if (src[size - 1] == '=')
    size--;
  if (size > 0 && src[size - 1] == '=')
    size--;

  return base64_decoded_size_fast(size);
}


extern const int8_t unbase64_table[256];


inline static int8_t unbase64(uint8_t x) {
  return unbase64_table[x];
}


template <typename TypeName>
bool base64_decode_group_slow(char* const dst, const size_t dstlen,
                              const TypeName* const src, const size_t srclen,
                              size_t* const i, size_t* const k) {
  uint8_t hi;
  uint8_t lo;
#define V(expr)                                                               \
  for (;;) {                                                                  \
    const uint8_t c = src[*i];                                                \
    lo = unbase64(c);                                                         \
    *i += 1;                                                                  \
    if (lo < 64)                                                              \
      break;  /* Legal character. */                                          \
    if (c == '=' || *i >= srclen)                                             \
      return false;  /* Stop decoding. */                                     \
  }                                                                           \
  expr;                                                                       \
  if (*i >= srclen)                                                           \
    return false;                                                             \
  if (*k >= dstlen)                                                           \
    return false;                                                             \
  hi = lo;
  V(/* Nothing. */);
  V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
  V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
  V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
#undef V
  return true;  // Continue decoding.
}


template <typename TypeName>
size_t base64_decode_fast(char* const dst, const size_t dstlen,
                          const TypeName* const src, const size_t srclen,
                          const size_t decoded_size) {
  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
  const size_t max_k = available / 3 * 3;
  size_t max_i = srclen / 4 * 4;
  size_t i = 0;
  size_t k = 0;
  while (i < max_i && k < max_k) {
    const uint32_t v =
        unbase64(src[i + 0]) << 24 |
        unbase64(src[i + 1]) << 16 |
        unbase64(src[i + 2]) << 8 |
        unbase64(src[i + 3]);
    // If MSB is set, input contains whitespace or is not valid base64.
    if (v & 0x80808080) {
      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
        return k;
      max_i = i + (srclen - i) / 4 * 4;  // Align max_i again.
    } else {
      dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
      dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
      dst[k + 2] = ((v >>  2) & 0xC0) | ((v >>  0) & 0x3F);
      i += 4;
      k += 3;
    }
  }
  if (i < srclen && k < dstlen) {
    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
  }
  return k;
}


template <typename TypeName>
size_t base64_decode(char* const dst, const size_t dstlen,
                     const TypeName* const src, const size_t srclen) {
  const size_t decoded_size = base64_decoded_size(src, srclen);
  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
}

static size_t base64_encode(const char* src,
                            size_t slen,
                            char* dst,
                            size_t dlen) {
  // We know how much we'll write, just make sure that there's space.
  CHECK(dlen >= base64_encoded_size(slen) &&
        "not enough space provided for base64 encode");

  dlen = base64_encoded_size(slen);

  unsigned a;
  unsigned b;
  unsigned c;
  unsigned i;
  unsigned k;
  unsigned n;

  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                              "abcdefghijklmnopqrstuvwxyz"
                              "0123456789+/";

  i = 0;
  k = 0;
  n = slen / 3 * 3;

  while (i < n) {
    a = src[i + 0] & 0xff;
    b = src[i + 1] & 0xff;
    c = src[i + 2] & 0xff;

    dst[k + 0] = table[a >> 2];
    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
    dst[k + 3] = table[c & 0x3f];

    i += 3;
    k += 4;
  }

  if (n != slen) {
    switch (slen - n) {
      case 1:
        a = src[i + 0] & 0xff;
        dst[k + 0] = table[a >> 2];
        dst[k + 1] = table[(a & 3) << 4];
        dst[k + 2] = '=';
        dst[k + 3] = '=';
        break;

      case 2:
        a = src[i + 0] & 0xff;
        b = src[i + 1] & 0xff;
        dst[k + 0] = table[a >> 2];
        dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
        dst[k + 2] = table[(b & 0x0f) << 2];
        dst[k + 3] = '=';
        break;
    }
  }

  return dlen;
}
}  // namespace node


#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_BASE64_H_


Generated by: GCOVR (Version 3.4)

Line	Branch	Exec	Source
1			#ifndef SRC_BASE64_H_
2			#define SRC_BASE64_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "util.h"
7
8			#include <cstddef>
9			#include <cstdint>
10
11			namespace node {
12			//// Base 64 ////
13		16513	static inline constexpr size_t base64_encoded_size(size_t size) {
14		16513	return ((size + 2 - ((size + 2) % 3)) / 3 * 4);
15			}
16
17			// Doesn't check for padding at the end. Can be 1-2 bytes over.
18		401843	static inline size_t base64_decoded_size_fast(size_t size) {
19		401843	size_t remainder = size % 4;
20
21		401843	size = (size / 4) * 3;
22	✓✓	401843	if (remainder) {
23	✓✓✗✓	401784	if (size == 0 && remainder == 1) {
24			// special case: 1-byte input cannot be decoded
25			size = 0;
26			} else {
27			// non-padded input, add 1 or 2 extra bytes
28	✓✓	401784	size += 1 + (remainder == 3);
29			}
30			}
31
32		401843	return size;
33			}
34
35			template <typename TypeName>
36		401833	size_t base64_decoded_size(const TypeName* src, size_t size) {
37	✗✓✗✓	401833	if (size == 0)
38			return 0;
39
40	✓✓✓✓	401833	if (src[size - 1] == '=')
41		401755	size--;
42	✓✗✓✓ ✓✗✓✓	401833	if (size > 0 && src[size - 1] == '=')
43		401617	size--;
44
45		401833	return base64_decoded_size_fast(size);
46			}
47
48
49			extern const int8_t unbase64_table[256];
50
51
52		48929774	inline static int8_t unbase64(uint8_t x) {
53		48929774	return unbase64_table[x];
54			}
55
56
57			template <typename TypeName>
58		401860	bool base64_decode_group_slow(char* const dst, const size_t dstlen,
59			const TypeName* const src, const size_t srclen,
60			size_t* const i, size_t* const k) {
61			uint8_t hi;
62			uint8_t lo;
63			#define V(expr) \
64			for (;;) { \
65			const uint8_t c = src[*i]; \
66			lo = unbase64(c); \
67			*i += 1; \
68			if (lo < 64) \
69			break; /* Legal character. */ \
70			if (c == '=' \|\| *i >= srclen) \
71			return false; /* Stop decoding. */ \
72			} \
73			expr; \
74			if (*i >= srclen) \
75			return false; \
76			if (*k >= dstlen) \
77			return false; \
78			hi = lo;
79	✓✓✓✓ ✓✓✗✓ ✗✓✓✗ ✗✗✗✗ ✗✓✗✓	401860	V(/* Nothing. */);
80	✓✗✗✗ ✗✗✓✓ ✓✓✓✗ ✗✗✗✗ ✗✓✓✓	401812	V(dst[(*k)++] = ((hi & 0x3F) << 2) \| ((lo & 0x30) >> 4));
81	✓✓✓✗ ✓✓✓✓ ✓✓✓✓ ✗✓✗✗ ✗✓✓✗	185	V(dst[(*k)++] = ((hi & 0x0F) << 4) \| ((lo & 0x3C) >> 2));
82	✓✓✗✓ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗	45	V(dst[(*k)++] = ((hi & 0x03) << 6) \| ((lo & 0x3F) >> 0));
83			#undef V
84		32	return true; // Continue decoding.
85			}
86
87
88			template <typename TypeName>
89		401828	size_t base64_decode_fast(char* const dst, const size_t dstlen,
90			const TypeName* const src, const size_t srclen,
91			const size_t decoded_size) {
92	✓✓✗✓	401828	const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
93		401828	const size_t max_k = available / 3 * 3;
94		401828	size_t max_i = srclen / 4 * 4;
95		401828	size_t i = 0;
96		401828	size_t k = 0;
97	✓✓✓✓ ✓✓✓✓	12835113	while (i < max_i && k < max_k) {
98			const uint32_t v =
99		12031468	unbase64(src[i + 0]) << 24 \|
100		12031468	unbase64(src[i + 1]) << 16 \|
101		12031468	unbase64(src[i + 2]) << 8 \|
102		36094404	unbase64(src[i + 3]);
103			// If MSB is set, input contains whitespace or is not valid base64.
104	✓✓✗✓	12031468	if (v & 0x80808080) {
105	✓✓✗✗	43	if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
106		11	return k;
107		32	max_i = i + (srclen - i) / 4 * 4; // Align max_i again.
108			} else {
109		12031425	dst[k + 0] = ((v >> 22) & 0xFC) \| ((v >> 20) & 0x03);
110		12031425	dst[k + 1] = ((v >> 12) & 0xF0) \| ((v >> 10) & 0x0F);
111		12031425	dst[k + 2] = ((v >> 2) & 0xC0) \| ((v >> 0) & 0x3F);
112		12031425	i += 4;
113		12031425	k += 3;
114			}
115			}
116	✓✓✓✓ ✓✓✓✗	401817	if (i < srclen && k < dstlen) {
117		401773	base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
118			}
119		401817	return k;
120			}
121
122
123			template <typename TypeName>
124		401828	size_t base64_decode(char* const dst, const size_t dstlen,
125			const TypeName* const src, const size_t srclen) {
126		401828	const size_t decoded_size = base64_decoded_size(src, srclen);
127		401828	return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
128			}
129
130		5510	static size_t base64_encode(const char* src,
131			size_t slen,
132			char* dst,
133			size_t dlen) {
134			// We know how much we'll write, just make sure that there's space.
135	✗✓✗✓	5510	CHECK(dlen >= base64_encoded_size(slen) &&
136			"not enough space provided for base64 encode");
137
138		5510	dlen = base64_encoded_size(slen);
139
140			unsigned a;
141			unsigned b;
142			unsigned c;
143			unsigned i;
144			unsigned k;
145			unsigned n;
146
147			static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
148			"abcdefghijklmnopqrstuvwxyz"
149			"0123456789+/";
150
151		5510	i = 0;
152		5510	k = 0;
153		5510	n = slen / 3 * 3;
154
155	✓✓	362611332	while (i < n) {
156		362600312	a = src[i + 0] & 0xff;
157		362600312	b = src[i + 1] & 0xff;
158		362600312	c = src[i + 2] & 0xff;
159
160		362600312	dst[k + 0] = table[a >> 2];
161		362600312	dst[k + 1] = table[((a & 3) << 4) \| (b >> 4)];
162		362600312	dst[k + 2] = table[((b & 0x0f) << 2) \| (c >> 6)];
163		362600312	dst[k + 3] = table[c & 0x3f];
164
165		362600312	i += 3;
166		362600312	k += 4;
167			}
168
169	✓✓	5510	if (n != slen) {
170	✓✓✗	4844	switch (slen - n) {
171			case 1:
172		593	a = src[i + 0] & 0xff;
173		593	dst[k + 0] = table[a >> 2];
174		593	dst[k + 1] = table[(a & 3) << 4];
175		593	dst[k + 2] = '=';
176		593	dst[k + 3] = '=';
177		593	break;
178
179			case 2:
180		4251	a = src[i + 0] & 0xff;
181		4251	b = src[i + 1] & 0xff;
182		4251	dst[k + 0] = table[a >> 2];
183		4251	dst[k + 1] = table[((a & 3) << 4) \| (b >> 4)];
184		4251	dst[k + 2] = table[(b & 0x0f) << 2];
185		4251	dst[k + 3] = '=';
186		4251	break;
187			}
188			}
189
190		5510	return dlen;
191			}
192			} // namespace node
193
194
195			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
196
197			#endif // SRC_BASE64_H_