Coverage Report

Created: 2026-09-28 08:21

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/cairo/src/cairo-freelist-private.h
Line
Count
Source
1
/*
2
 * Copyright © 2006 Joonas Pihlaja
3
 *
4
 * Permission to use, copy, modify, distribute, and sell this software and its
5
 * documentation for any purpose is hereby granted without fee, provided that
6
 * the above copyright notice appear in all copies and that both that copyright
7
 * notice and this permission notice appear in supporting documentation, and
8
 * that the name of the copyright holders not be used in advertising or
9
 * publicity pertaining to distribution of the software without specific,
10
 * written prior permission.  The copyright holders make no representations
11
 * about the suitability of this software for any purpose.  It is provided "as
12
 * is" without express or implied warranty.
13
 *
14
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20
 * OF THIS SOFTWARE.
21
 */
22
#ifndef CAIRO_FREELIST_H
23
#define CAIRO_FREELIST_H
24
25
#include "cairo-types-private.h"
26
#include "cairo-compiler-private.h"
27
#include "cairo-freelist-type-private.h"
28
29
/* for stand-alone compilation*/
30
#ifndef VG
31
#define VG(x)
32
#endif
33
34
#ifndef NULL
35
#define NULL (void *) 0
36
#endif
37
38
/* Initialise a freelist that will be responsible for allocating
39
 * nodes of size nodesize. */
40
cairo_private void
41
_cairo_freelist_init (cairo_freelist_t *freelist, unsigned nodesize);
42
43
/* Deallocate any nodes in the freelist. */
44
cairo_private void
45
_cairo_freelist_fini (cairo_freelist_t *freelist);
46
47
/* Allocate a new node from the freelist.  If the freelist contains no
48
 * nodes, a new one will be allocated using malloc().  The caller is
49
 * responsible for calling _cairo_freelist_free() or free() on the
50
 * returned node.  Returns %NULL on memory allocation error. */
51
cairo_private void *
52
_cairo_freelist_alloc (cairo_freelist_t *freelist);
53
54
/* Allocate a new node from the freelist.  If the freelist contains no
55
 * nodes, a new one will be allocated using calloc().  The caller is
56
 * responsible for calling _cairo_freelist_free() or free() on the
57
 * returned node.  Returns %NULL on memory allocation error. */
58
cairo_private void *
59
_cairo_freelist_calloc (cairo_freelist_t *freelist);
60
61
/* Return a node to the freelist. This does not deallocate the memory,
62
 * but makes it available for later reuse by
63
 * _cairo_freelist_alloc(). */
64
cairo_private void
65
_cairo_freelist_free (cairo_freelist_t *freelist, void *node);
66
67
68
cairo_private void
69
_cairo_freepool_init (cairo_freepool_t *freepool, unsigned nodesize);
70
71
cairo_private void
72
_cairo_freepool_fini (cairo_freepool_t *freepool);
73
74
static inline void
75
_cairo_freepool_reset (cairo_freepool_t *freepool)
76
24
{
77
24
    while (freepool->pools != &freepool->embedded_pool) {
78
0
  cairo_freelist_pool_t *pool = freepool->pools;
79
0
  freepool->pools = pool->next;
80
0
  pool->next = freepool->freepools;
81
0
  freepool->freepools = pool;
82
0
    }
83
84
24
    freepool->embedded_pool.rem = sizeof (freepool->embedded_data);
85
24
    freepool->embedded_pool.data = freepool->embedded_data;
86
24
}
Unexecuted instantiation: cairo-bentley-ottmann.c:_cairo_freepool_reset
Unexecuted instantiation: cairo-contour.c:_cairo_freepool_reset
Unexecuted instantiation: cairo-freelist.c:_cairo_freepool_reset
Unexecuted instantiation: cairo-polygon-intersect.c:_cairo_freepool_reset
Unexecuted instantiation: cairo-polygon-reduce.c:_cairo_freepool_reset
cairo-rectangular-scan-converter.c:_cairo_freepool_reset
Line
Count
Source
76
24
{
77
24
    while (freepool->pools != &freepool->embedded_pool) {
78
0
  cairo_freelist_pool_t *pool = freepool->pools;
79
0
  freepool->pools = pool->next;
80
0
  pool->next = freepool->freepools;
81
0
  freepool->freepools = pool;
82
0
    }
83
84
24
    freepool->embedded_pool.rem = sizeof (freepool->embedded_data);
85
24
    freepool->embedded_pool.data = freepool->embedded_data;
86
24
}
87
88
cairo_private void *
89
_cairo_freepool_alloc_from_new_pool (cairo_freepool_t *freepool);
90
91
static inline void *
92
_cairo_freepool_alloc_from_pool (cairo_freepool_t *freepool)
93
533
{
94
533
    cairo_freelist_pool_t *pool;
95
533
    uint8_t *ptr;
96
97
533
    pool = freepool->pools;
98
533
    if (unlikely (freepool->nodesize > pool->rem))
99
0
  return _cairo_freepool_alloc_from_new_pool (freepool);
100
101
533
    ptr = pool->data;
102
533
    pool->data += freepool->nodesize;
103
533
    pool->rem -= freepool->nodesize;
104
533
    VG (VALGRIND_MAKE_MEM_UNDEFINED (ptr, freepool->nodesize));
105
533
    return ptr;
106
533
}
cairo-bentley-ottmann.c:_cairo_freepool_alloc_from_pool
Line
Count
Source
93
170
{
94
170
    cairo_freelist_pool_t *pool;
95
170
    uint8_t *ptr;
96
97
170
    pool = freepool->pools;
98
170
    if (unlikely (freepool->nodesize > pool->rem))
99
0
  return _cairo_freepool_alloc_from_new_pool (freepool);
100
101
170
    ptr = pool->data;
102
170
    pool->data += freepool->nodesize;
103
170
    pool->rem -= freepool->nodesize;
104
170
    VG (VALGRIND_MAKE_MEM_UNDEFINED (ptr, freepool->nodesize));
105
170
    return ptr;
106
170
}
Unexecuted instantiation: cairo-contour.c:_cairo_freepool_alloc_from_pool
Unexecuted instantiation: cairo-freelist.c:_cairo_freepool_alloc_from_pool
cairo-polygon-intersect.c:_cairo_freepool_alloc_from_pool
Line
Count
Source
93
165
{
94
165
    cairo_freelist_pool_t *pool;
95
165
    uint8_t *ptr;
96
97
165
    pool = freepool->pools;
98
165
    if (unlikely (freepool->nodesize > pool->rem))
99
0
  return _cairo_freepool_alloc_from_new_pool (freepool);
100
101
165
    ptr = pool->data;
102
165
    pool->data += freepool->nodesize;
103
165
    pool->rem -= freepool->nodesize;
104
165
    VG (VALGRIND_MAKE_MEM_UNDEFINED (ptr, freepool->nodesize));
105
165
    return ptr;
106
165
}
Unexecuted instantiation: cairo-polygon-reduce.c:_cairo_freepool_alloc_from_pool
cairo-rectangular-scan-converter.c:_cairo_freepool_alloc_from_pool
Line
Count
Source
93
198
{
94
198
    cairo_freelist_pool_t *pool;
95
198
    uint8_t *ptr;
96
97
198
    pool = freepool->pools;
98
198
    if (unlikely (freepool->nodesize > pool->rem))
99
0
  return _cairo_freepool_alloc_from_new_pool (freepool);
100
101
198
    ptr = pool->data;
102
198
    pool->data += freepool->nodesize;
103
198
    pool->rem -= freepool->nodesize;
104
198
    VG (VALGRIND_MAKE_MEM_UNDEFINED (ptr, freepool->nodesize));
105
198
    return ptr;
106
198
}
107
108
static inline void *
109
_cairo_freepool_alloc (cairo_freepool_t *freepool)
110
1.07k
{
111
1.07k
    cairo_freelist_node_t *node;
112
113
1.07k
    node = freepool->first_free_node;
114
1.07k
    if (node == NULL)
115
533
  return _cairo_freepool_alloc_from_pool (freepool);
116
117
544
    VG (VALGRIND_MAKE_MEM_DEFINED (node, sizeof (node->next)));
118
544
    freepool->first_free_node = node->next;
119
544
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
120
121
544
    return node;
122
1.07k
}
cairo-bentley-ottmann.c:_cairo_freepool_alloc
Line
Count
Source
110
469
{
111
469
    cairo_freelist_node_t *node;
112
113
469
    node = freepool->first_free_node;
114
469
    if (node == NULL)
115
170
  return _cairo_freepool_alloc_from_pool (freepool);
116
117
299
    VG (VALGRIND_MAKE_MEM_DEFINED (node, sizeof (node->next)));
118
299
    freepool->first_free_node = node->next;
119
299
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
120
121
299
    return node;
122
469
}
Unexecuted instantiation: cairo-contour.c:_cairo_freepool_alloc
Unexecuted instantiation: cairo-freelist.c:_cairo_freepool_alloc
cairo-polygon-intersect.c:_cairo_freepool_alloc
Line
Count
Source
110
410
{
111
410
    cairo_freelist_node_t *node;
112
113
410
    node = freepool->first_free_node;
114
410
    if (node == NULL)
115
165
  return _cairo_freepool_alloc_from_pool (freepool);
116
117
245
    VG (VALGRIND_MAKE_MEM_DEFINED (node, sizeof (node->next)));
118
245
    freepool->first_free_node = node->next;
119
245
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
120
121
245
    return node;
122
410
}
Unexecuted instantiation: cairo-polygon-reduce.c:_cairo_freepool_alloc
cairo-rectangular-scan-converter.c:_cairo_freepool_alloc
Line
Count
Source
110
198
{
111
198
    cairo_freelist_node_t *node;
112
113
198
    node = freepool->first_free_node;
114
198
    if (node == NULL)
115
198
  return _cairo_freepool_alloc_from_pool (freepool);
116
117
0
    VG (VALGRIND_MAKE_MEM_DEFINED (node, sizeof (node->next)));
118
0
    freepool->first_free_node = node->next;
119
0
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
120
121
0
    return node;
122
198
}
123
124
cairo_private cairo_status_t
125
_cairo_freepool_alloc_array (cairo_freepool_t *freepool,
126
           int count,
127
           void **array);
128
129
static inline void
130
_cairo_freepool_free (cairo_freepool_t *freepool, void *ptr)
131
879
{
132
879
    cairo_freelist_node_t *node = ptr;
133
134
879
    node->next = freepool->first_free_node;
135
879
    freepool->first_free_node = node;
136
879
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
137
879
}
cairo-bentley-ottmann.c:_cairo_freepool_free
Line
Count
Source
131
469
{
132
469
    cairo_freelist_node_t *node = ptr;
133
134
469
    node->next = freepool->first_free_node;
135
469
    freepool->first_free_node = node;
136
469
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
137
469
}
Unexecuted instantiation: cairo-contour.c:_cairo_freepool_free
Unexecuted instantiation: cairo-freelist.c:_cairo_freepool_free
cairo-polygon-intersect.c:_cairo_freepool_free
Line
Count
Source
131
410
{
132
410
    cairo_freelist_node_t *node = ptr;
133
134
410
    node->next = freepool->first_free_node;
135
410
    freepool->first_free_node = node;
136
410
    VG (VALGRIND_MAKE_MEM_UNDEFINED (node, freepool->nodesize));
137
410
}
Unexecuted instantiation: cairo-polygon-reduce.c:_cairo_freepool_free
Unexecuted instantiation: cairo-rectangular-scan-converter.c:_cairo_freepool_free
138
139
#endif /* CAIRO_FREELIST_H */