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-inl.h	Lines:	82	83	98.8 %
Date:	2020-11-20 19:51:53	Branches:	89	133	66.9 %


#ifndef SRC_BASE64_INL_H_
#define SRC_BASE64_INL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "base64.h"
#include "util.h"

namespace node {

extern const int8_t unbase64_table[256];


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


inline uint32_t ReadUint32BE(const unsigned char* p) {
  return static_cast<uint32_t>(p[0] << 24U) |
         static_cast<uint32_t>(p[1] << 16U) |
         static_cast<uint32_t>(p[2] << 8U) |
         static_cast<uint32_t>(p[3]);
}


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 unsigned char txt[] = {
      static_cast<unsigned char>(unbase64(src[i + 0])),
      static_cast<unsigned char>(unbase64(src[i + 1])),
      static_cast<unsigned char>(unbase64(src[i + 2])),
      static_cast<unsigned char>(unbase64(src[i + 3])),
    };

    const uint32_t v = ReadUint32BE(txt);
    // 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_decoded_size(const TypeName* src, size_t size) {
  // 1-byte input cannot be decoded
  if (size < 2)
    return 0;

  if (src[size - 1] == '=') {
    size--;
    if (src[size - 1] == '=')
      size--;
  }
  return base64_decoded_size_fast(size);
}


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);
}


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

  dlen = base64_encoded_size(slen, mode);

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

  const char* table = base64_select_table(mode);

  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;
  }

  switch (slen - n) {
    case 1:
      a = src[i + 0] & 0xff;
      dst[k + 0] = table[a >> 2];
      dst[k + 1] = table[(a & 3) << 4];
      if (mode == Base64Mode::NORMAL) {
        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];
      if (mode == Base64Mode::NORMAL)
        dst[k + 3] = '=';
      break;
  }

  return dlen;
}

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_BASE64_INL_H_


Generated by: GCOVR (Version 3.4)

Line	Branch	Exec	Source
1			#ifndef SRC_BASE64_INL_H_
2			#define SRC_BASE64_INL_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "base64.h"
7			#include "util.h"
8
9			namespace node {
10
11			extern const int8_t unbase64_table[256];
12
13
14		15747411	inline static int8_t unbase64(uint8_t x) {
15		15747411	return unbase64_table[x];
16			}
17
18
19		3935829	inline uint32_t ReadUint32BE(const unsigned char* p) {
20		7871658	return static_cast<uint32_t>(p[0] << 24U) \|
21		7871658	static_cast<uint32_t>(p[1] << 16U) \|
22		3935829	static_cast<uint32_t>(p[2] << 8U) \|
23		3935829	static_cast<uint32_t>(p[3]);
24			}
25
26
27			template <typename TypeName>
28		1807	bool base64_decode_group_slow(char* const dst, const size_t dstlen,
29			const TypeName* const src, const size_t srclen,
30			size_t* const i, size_t* const k) {
31			uint8_t hi;
32			uint8_t lo;
33			#define V(expr) \
34			for (;;) { \
35			const uint8_t c = src[*i]; \
36			lo = unbase64(c); \
37			*i += 1; \
38			if (lo < 64) \
39			break; /* Legal character. */ \
40			if (c == '=' \|\| *i >= srclen) \
41			return false; /* Stop decoding. */ \
42			} \
43			expr; \
44			if (*i >= srclen) \
45			return false; \
46			if (*k >= dstlen) \
47			return false; \
48			hi = lo;
49	✓✓✓✓ ✗✓✗✓ ✗✓✓✗ ✗✗✗✗ ✗✓✗✓	1807	V(/* Nothing. */);
50	✓✓✓✗ ✗✓✓✓ ✓✓✓✗ ✗✗✗✗ ✗✓✓✓	1753	V(dst[(*k)++] = ((hi & 0x3F) << 2) \| ((lo & 0x30) >> 4));
51	✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✗✓✗✗ ✗✓✓✗	566	V(dst[(*k)++] = ((hi & 0x0F) << 4) \| ((lo & 0x3C) >> 2));
52	✓✓✓✓ ✗✓✓✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗	69	V(dst[(*k)++] = ((hi & 0x03) << 6) \| ((lo & 0x3F) >> 0));
53			#undef V
54		54	return true; // Continue decoding.
55			}
56
57
58			template <typename TypeName>
59		2036	size_t base64_decode_fast(char* const dst, const size_t dstlen,
60			const TypeName* const src, const size_t srclen,
61			const size_t decoded_size) {
62	✓✓✗✓	2036	const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
63		2036	const size_t max_k = available / 3 * 3;
64		2036	size_t max_i = srclen / 4 * 4;
65		2036	size_t i = 0;
66		2036	size_t k = 0;
67	✓✓✓✓ ✓✓✓✓	7873616	while (i < max_i && k < max_k) {
68			const unsigned char txt[] = {
69		3935804	static_cast<unsigned char>(unbase64(src[i + 0])),
70		3935804	static_cast<unsigned char>(unbase64(src[i + 1])),
71		3935804	static_cast<unsigned char>(unbase64(src[i + 2])),
72		3935804	static_cast<unsigned char>(unbase64(src[i + 3])),
73		15743216	};
74
75		3935804	const uint32_t v = ReadUint32BE(txt);
76			// If MSB is set, input contains whitespace or is not valid base64.
77	✓✓✗✓	3935804	if (v & 0x80808080) {
78	✓✓✗✗	68	if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
79		14	return k;
80		54	max_i = i + (srclen - i) / 4 * 4; // Align max_i again.
81			} else {
82		3935736	dst[k + 0] = ((v >> 22) & 0xFC) \| ((v >> 20) & 0x03);
83		3935736	dst[k + 1] = ((v >> 12) & 0xF0) \| ((v >> 10) & 0x0F);
84		3935736	dst[k + 2] = ((v >> 2) & 0xC0) \| ((v >> 0) & 0x3F);
85		3935736	i += 4;
86		3935736	k += 3;
87			}
88			}
89	✓✓✓✓ ✓✓✓✗	2022	if (i < srclen && k < dstlen) {
90		1675	base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
91			}
92		2022	return k;
93			}
94
95
96			template <typename TypeName>
97		3170	size_t base64_decoded_size(const TypeName* src, size_t size) {
98			// 1-byte input cannot be decoded
99	✗✓✗✓	3170	if (size < 2)
100			return 0;
101
102	✓✓✓✓	3170	if (src[size - 1] == '=') {
103		889	size--;
104	✓✓✓✓	889	if (src[size - 1] == '=')
105		757	size--;
106			}
107		3170	return base64_decoded_size_fast(size);
108			}
109
110
111			template <typename TypeName>
112		2036	size_t base64_decode(char* const dst, const size_t dstlen,
113			const TypeName* const src, const size_t srclen) {
114		2036	const size_t decoded_size = base64_decoded_size(src, srclen);
115		2036	return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
116			}
117
118
119		2933	inline size_t base64_encode(const char* src,
120			size_t slen,
121			char* dst,
122			size_t dlen,
123			Base64Mode mode) {
124			// We know how much we'll write, just make sure that there's space.
125	✗✓✗✓	2933	CHECK(dlen >= base64_encoded_size(slen, mode) &&
126			"not enough space provided for base64 encode");
127
128		2933	dlen = base64_encoded_size(slen, mode);
129
130			unsigned a;
131			unsigned b;
132			unsigned c;
133			unsigned i;
134			unsigned k;
135			unsigned n;
136
137		2933	const char* table = base64_select_table(mode);
138
139		2933	i = 0;
140		2933	k = 0;
141		2933	n = slen / 3 * 3;
142
143	✓✓	367279205	while (i < n) {
144		183638136	a = src[i + 0] & 0xff;
145		183638136	b = src[i + 1] & 0xff;
146		183638136	c = src[i + 2] & 0xff;
147
148		183638136	dst[k + 0] = table[a >> 2];
149		183638136	dst[k + 1] = table[((a & 3) << 4) \| (b >> 4)];
150		183638136	dst[k + 2] = table[((b & 0x0f) << 2) \| (c >> 6)];
151		183638136	dst[k + 3] = table[c & 0x3f];
152
153		183638136	i += 3;
154		183638136	k += 4;
155			}
156
157	✓✓✓	2933	switch (slen - n) {
158			case 1:
159		916	a = src[i + 0] & 0xff;
160		916	dst[k + 0] = table[a >> 2];
161		916	dst[k + 1] = table[(a & 3) << 4];
162	✓✓	916	if (mode == Base64Mode::NORMAL) {
163		511	dst[k + 2] = '=';
164		511	dst[k + 3] = '=';
165			}
166		916	break;
167			case 2:
168		472	a = src[i + 0] & 0xff;
169		472	b = src[i + 1] & 0xff;
170		472	dst[k + 0] = table[a >> 2];
171		472	dst[k + 1] = table[((a & 3) << 4) \| (b >> 4)];
172		472	dst[k + 2] = table[(b & 0x0f) << 2];
173	✓✓	472	if (mode == Base64Mode::NORMAL)
174		190	dst[k + 3] = '=';
175		472	break;
176			}
177
178		2933	return dlen;
179			}
180
181			} // namespace node
182
183			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
184
185			#endif // SRC_BASE64_INL_H_