Coverage Report

Created: 2025-10-13 06:15

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/cpython3/Objects/stringlib/find_max_char.h
Line
Count
Source
1
/* Finding the optimal width of unicode characters in a buffer */
2
3
/* find_max_char for one-byte will work for bytes objects as well. */
4
#if !STRINGLIB_IS_UNICODE && STRINGLIB_SIZEOF_CHAR > 1
5
# error "find_max_char.h is specific to Unicode"
6
#endif
7
8
/* Mask to quickly check whether a C 'size_t' contains a
9
   non-ASCII, UTF8-encoded char. */
10
#if (SIZEOF_SIZE_T == 8)
11
2.34M
# define UCS1_ASCII_CHAR_MASK 0x8080808080808080ULL
12
#elif (SIZEOF_SIZE_T == 4)
13
# define UCS1_ASCII_CHAR_MASK 0x80808080U
14
#else
15
# error C 'size_t' size should be either 4 or 8!
16
#endif
17
18
#if STRINGLIB_SIZEOF_CHAR == 1
19
20
Py_LOCAL_INLINE(Py_UCS4)
21
STRINGLIB(find_max_char)(const STRINGLIB_CHAR *begin, const STRINGLIB_CHAR *end)
22
883k
{
23
883k
    const unsigned char *p = (const unsigned char *) begin;
24
883k
    const unsigned char *_end = (const unsigned char *)end;
25
26
5.82M
    while (p < _end) {
27
5.00M
        if (_Py_IS_ALIGNED(p, ALIGNOF_SIZE_T)) {
28
            /* Help register allocation */
29
663k
            const unsigned char *_p = p;
30
3.00M
            while (_p + SIZEOF_SIZE_T <= _end) {
31
2.34M
                size_t value = *(const size_t *) _p;
32
2.34M
                if (value & UCS1_ASCII_CHAR_MASK)
33
5.47k
                    return 255;
34
2.33M
                _p += SIZEOF_SIZE_T;
35
2.33M
            }
36
657k
            p = _p;
37
657k
            if (p == _end)
38
50.4k
                break;
39
657k
        }
40
4.94M
        if (*p++ & 0x80)
41
5.75k
            return 255;
42
4.94M
    }
43
872k
    return 127;
44
883k
}
unicodeobject.c:ucs1lib_find_max_char
Line
Count
Source
22
883k
{
23
883k
    const unsigned char *p = (const unsigned char *) begin;
24
883k
    const unsigned char *_end = (const unsigned char *)end;
25
26
5.82M
    while (p < _end) {
27
5.00M
        if (_Py_IS_ALIGNED(p, ALIGNOF_SIZE_T)) {
28
            /* Help register allocation */
29
663k
            const unsigned char *_p = p;
30
3.00M
            while (_p + SIZEOF_SIZE_T <= _end) {
31
2.34M
                size_t value = *(const size_t *) _p;
32
2.34M
                if (value & UCS1_ASCII_CHAR_MASK)
33
5.47k
                    return 255;
34
2.33M
                _p += SIZEOF_SIZE_T;
35
2.33M
            }
36
657k
            p = _p;
37
657k
            if (p == _end)
38
50.4k
                break;
39
657k
        }
40
4.94M
        if (*p++ & 0x80)
41
5.75k
            return 255;
42
4.94M
    }
43
872k
    return 127;
44
883k
}
Unexecuted instantiation: unicodeobject.c:asciilib_find_max_char
Unexecuted instantiation: bytes_methods.c:stringlib_find_max_char
45
46
#undef ASCII_CHAR_MASK
47
48
#else /* STRINGLIB_SIZEOF_CHAR == 1 */
49
50
1.07M
#define MASK_ASCII 0xFFFFFF80
51
542k
#define MASK_UCS1 0xFFFFFF00
52
531k
#define MASK_UCS2 0xFFFF0000
53
54
621k
#define MAX_CHAR_ASCII 0x7f
55
329k
#define MAX_CHAR_UCS1  0xff
56
335k
#define MAX_CHAR_UCS2  0xffff
57
408k
#define MAX_CHAR_UCS4  0x10ffff
58
59
Py_LOCAL_INLINE(Py_UCS4)
60
STRINGLIB(find_max_char)(const STRINGLIB_CHAR *begin, const STRINGLIB_CHAR *end)
61
621k
{
62
#if STRINGLIB_SIZEOF_CHAR == 2
63
212k
    const Py_UCS4 mask_limit = MASK_UCS1;
64
212k
    const Py_UCS4 max_char_limit = MAX_CHAR_UCS2;
65
#elif STRINGLIB_SIZEOF_CHAR == 4
66
408k
    const Py_UCS4 mask_limit = MASK_UCS2;
67
408k
    const Py_UCS4 max_char_limit = MAX_CHAR_UCS4;
68
#else
69
#error Invalid STRINGLIB_SIZEOF_CHAR (must be 1, 2 or 4)
70
#endif
71
621k
    Py_UCS4 mask;
72
621k
    Py_ssize_t n = end - begin;
73
621k
    const STRINGLIB_CHAR *p = begin;
74
621k
    const STRINGLIB_CHAR *unrolled_end = begin + _Py_SIZE_ROUND_DOWN(n, 4);
75
621k
    Py_UCS4 max_char;
76
77
621k
    max_char = MAX_CHAR_ASCII;
78
621k
    mask = MASK_ASCII;
79
11.0M
    while (p < unrolled_end) {
80
10.5M
        STRINGLIB_CHAR bits = p[0] | p[1] | p[2] | p[3];
81
10.5M
        if (bits & mask) {
82
447k
            if (mask == mask_limit) {
83
                /* Limit reached */
84
151k
                return max_char_limit;
85
151k
            }
86
296k
            if (mask == MASK_ASCII) {
87
230k
                max_char = MAX_CHAR_UCS1;
88
230k
                mask = MASK_UCS1;
89
230k
            }
90
66.1k
            else {
91
                /* mask can't be MASK_UCS2 because of mask_limit above */
92
66.1k
                assert(mask == MASK_UCS1);
93
66.1k
                max_char = MAX_CHAR_UCS2;
94
66.1k
                mask = MASK_UCS2;
95
66.1k
            }
96
            /* We check the new mask on the same chars in the next iteration */
97
296k
            continue;
98
296k
        }
99
10.1M
        p += 4;
100
10.1M
    }
101
1.32M
    while (p < end) {
102
902k
        if (p[0] & mask) {
103
204k
            if (mask == mask_limit) {
104
                /* Limit reached */
105
47.9k
                return max_char_limit;
106
47.9k
            }
107
156k
            if (mask == MASK_ASCII) {
108
99.7k
                max_char = MAX_CHAR_UCS1;
109
99.7k
                mask = MASK_UCS1;
110
99.7k
            }
111
56.7k
            else {
112
                /* mask can't be MASK_UCS2 because of mask_limit above */
113
56.7k
                assert(mask == MASK_UCS1);
114
56.7k
                max_char = MAX_CHAR_UCS2;
115
56.7k
                mask = MASK_UCS2;
116
56.7k
            }
117
            /* We check the new mask on the same chars in the next iteration */
118
156k
            continue;
119
156k
        }
120
697k
        p++;
121
697k
    }
122
421k
    return max_char;
123
469k
}
unicodeobject.c:ucs4lib_find_max_char
Line
Count
Source
61
408k
{
62
#if STRINGLIB_SIZEOF_CHAR == 2
63
    const Py_UCS4 mask_limit = MASK_UCS1;
64
    const Py_UCS4 max_char_limit = MAX_CHAR_UCS2;
65
#elif STRINGLIB_SIZEOF_CHAR == 4
66
408k
    const Py_UCS4 mask_limit = MASK_UCS2;
67
408k
    const Py_UCS4 max_char_limit = MAX_CHAR_UCS4;
68
#else
69
#error Invalid STRINGLIB_SIZEOF_CHAR (must be 1, 2 or 4)
70
#endif
71
408k
    Py_UCS4 mask;
72
408k
    Py_ssize_t n = end - begin;
73
408k
    const STRINGLIB_CHAR *p = begin;
74
408k
    const STRINGLIB_CHAR *unrolled_end = begin + _Py_SIZE_ROUND_DOWN(n, 4);
75
408k
    Py_UCS4 max_char;
76
77
408k
    max_char = MAX_CHAR_ASCII;
78
408k
    mask = MASK_ASCII;
79
9.04M
    while (p < unrolled_end) {
80
8.65M
        STRINGLIB_CHAR bits = p[0] | p[1] | p[2] | p[3];
81
8.65M
        if (bits & mask) {
82
187k
            if (mask == mask_limit) {
83
                /* Limit reached */
84
21.4k
                return max_char_limit;
85
21.4k
            }
86
165k
            if (mask == MASK_ASCII) {
87
99.7k
                max_char = MAX_CHAR_UCS1;
88
99.7k
                mask = MASK_UCS1;
89
99.7k
            }
90
66.1k
            else {
91
                /* mask can't be MASK_UCS2 because of mask_limit above */
92
66.1k
                assert(mask == MASK_UCS1);
93
66.1k
                max_char = MAX_CHAR_UCS2;
94
66.1k
                mask = MASK_UCS2;
95
66.1k
            }
96
            /* We check the new mask on the same chars in the next iteration */
97
165k
            continue;
98
165k
        }
99
8.47M
        p += 4;
100
8.47M
    }
101
1.13M
    while (p < end) {
102
759k
        if (p[0] & mask) {
103
128k
            if (mask == mask_limit) {
104
                /* Limit reached */
105
10.1k
                return max_char_limit;
106
10.1k
            }
107
117k
            if (mask == MASK_ASCII) {
108
61.1k
                max_char = MAX_CHAR_UCS1;
109
61.1k
                mask = MASK_UCS1;
110
61.1k
            }
111
56.7k
            else {
112
                /* mask can't be MASK_UCS2 because of mask_limit above */
113
56.7k
                assert(mask == MASK_UCS1);
114
56.7k
                max_char = MAX_CHAR_UCS2;
115
56.7k
                mask = MASK_UCS2;
116
56.7k
            }
117
            /* We check the new mask on the same chars in the next iteration */
118
117k
            continue;
119
117k
        }
120
631k
        p++;
121
631k
    }
122
376k
    return max_char;
123
386k
}
unicodeobject.c:ucs2lib_find_max_char
Line
Count
Source
61
212k
{
62
212k
#if STRINGLIB_SIZEOF_CHAR == 2
63
212k
    const Py_UCS4 mask_limit = MASK_UCS1;
64
212k
    const Py_UCS4 max_char_limit = MAX_CHAR_UCS2;
65
#elif STRINGLIB_SIZEOF_CHAR == 4
66
    const Py_UCS4 mask_limit = MASK_UCS2;
67
    const Py_UCS4 max_char_limit = MAX_CHAR_UCS4;
68
#else
69
#error Invalid STRINGLIB_SIZEOF_CHAR (must be 1, 2 or 4)
70
#endif
71
212k
    Py_UCS4 mask;
72
212k
    Py_ssize_t n = end - begin;
73
212k
    const STRINGLIB_CHAR *p = begin;
74
212k
    const STRINGLIB_CHAR *unrolled_end = begin + _Py_SIZE_ROUND_DOWN(n, 4);
75
212k
    Py_UCS4 max_char;
76
77
212k
    max_char = MAX_CHAR_ASCII;
78
212k
    mask = MASK_ASCII;
79
2.01M
    while (p < unrolled_end) {
80
1.93M
        STRINGLIB_CHAR bits = p[0] | p[1] | p[2] | p[3];
81
1.93M
        if (bits & mask) {
82
260k
            if (mask == mask_limit) {
83
                /* Limit reached */
84
130k
                return max_char_limit;
85
130k
            }
86
130k
            if (mask == MASK_ASCII) {
87
130k
                max_char = MAX_CHAR_UCS1;
88
130k
                mask = MASK_UCS1;
89
130k
            }
90
0
            else {
91
                /* mask can't be MASK_UCS2 because of mask_limit above */
92
0
                assert(mask == MASK_UCS1);
93
0
                max_char = MAX_CHAR_UCS2;
94
0
                mask = MASK_UCS2;
95
0
            }
96
            /* We check the new mask on the same chars in the next iteration */
97
130k
            continue;
98
130k
        }
99
1.67M
        p += 4;
100
1.67M
    }
101
187k
    while (p < end) {
102
143k
        if (p[0] & mask) {
103
76.3k
            if (mask == mask_limit) {
104
                /* Limit reached */
105
37.7k
                return max_char_limit;
106
37.7k
            }
107
38.5k
            if (mask == MASK_ASCII) {
108
38.5k
                max_char = MAX_CHAR_UCS1;
109
38.5k
                mask = MASK_UCS1;
110
38.5k
            }
111
0
            else {
112
                /* mask can't be MASK_UCS2 because of mask_limit above */
113
0
                assert(mask == MASK_UCS1);
114
0
                max_char = MAX_CHAR_UCS2;
115
0
                mask = MASK_UCS2;
116
0
            }
117
            /* We check the new mask on the same chars in the next iteration */
118
38.5k
            continue;
119
38.5k
        }
120
66.6k
        p++;
121
66.6k
    }
122
44.8k
    return max_char;
123
82.6k
}
124
125
#undef MASK_ASCII
126
#undef MASK_UCS1
127
#undef MASK_UCS2
128
#undef MAX_CHAR_ASCII
129
#undef MAX_CHAR_UCS1
130
#undef MAX_CHAR_UCS2
131
#undef MAX_CHAR_UCS4
132
133
#endif /* STRINGLIB_SIZEOF_CHAR == 1 */
134