1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#define NULL ((void *)0)
33
34typedef unsigned char uint8_t;
35typedef char int8_t;
36typedef unsigned int uint32_t;
37typedef int int32_t;
38typedef long ssize_t;
39typedef unsigned long long uint64_t;
40typedef long long int64_t;
41typedef _Bool bool;
42
43typedef struct va_list_str *va_list;
44
45
46
47typedef struct AddressSpace AddressSpace;
48typedef uint64_t hwaddr;
49typedef uint32_t MemTxResult;
50typedef uint64_t MemTxAttrs;
51
52static void __bufwrite(uint8_t *buf, ssize_t len)
53{
54 int first, last;
55 __coverity_negative_sink__(len);
56 if (len == 0) return;
57 buf[0] = first;
58 buf[len-1] = last;
59 __coverity_writeall__(buf);
60}
61
62static void __bufread(uint8_t *buf, ssize_t len)
63{
64 __coverity_negative_sink__(len);
65 if (len == 0) return;
66 int first = buf[0];
67 int last = buf[len-1];
68}
69
70MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,
71 uint8_t *buf, int len, bool is_write)
72{
73 MemTxResult result;
74
75
76
77 if (is_write) __bufread(buf, len); else __bufwrite(buf, len);
78
79 return result;
80}
81
82
83
84typedef struct {} name2keysym_t;
85static int get_keysym(const name2keysym_t *table,
86 const char *name)
87{
88 int result;
89 if (result > 0) {
90 __coverity_tainted_string_sanitize_content__(name);
91 return result;
92 } else {
93 return 0;
94 }
95}
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120void *g_malloc_n(size_t nmemb, size_t size)
121{
122 size_t sz;
123 void *ptr;
124
125 __coverity_negative_sink__(nmemb);
126 __coverity_negative_sink__(size);
127 sz = nmemb * size;
128 ptr = __coverity_alloc__(sz);
129 __coverity_mark_as_uninitialized_buffer__(ptr);
130 __coverity_mark_as_afm_allocated__(ptr, "g_free");
131 return ptr;
132}
133
134void *g_malloc0_n(size_t nmemb, size_t size)
135{
136 size_t sz;
137 void *ptr;
138
139 __coverity_negative_sink__(nmemb);
140 __coverity_negative_sink__(size);
141 sz = nmemb * size;
142 ptr = __coverity_alloc__(sz);
143 __coverity_writeall0__(ptr);
144 __coverity_mark_as_afm_allocated__(ptr, "g_free");
145 return ptr;
146}
147
148void *g_realloc_n(void *ptr, size_t nmemb, size_t size)
149{
150 size_t sz;
151
152 __coverity_negative_sink__(nmemb);
153 __coverity_negative_sink__(size);
154 sz = nmemb * size;
155 __coverity_escape__(ptr);
156 ptr = __coverity_alloc__(sz);
157
158
159
160
161 __coverity_writeall__(ptr);
162 __coverity_mark_as_afm_allocated__(ptr, "g_free");
163 return ptr;
164}
165
166void g_free(void *ptr)
167{
168 __coverity_free__(ptr);
169 __coverity_mark_as_afm_freed__(ptr, "g_free");
170}
171
172
173
174
175
176
177void *g_try_malloc_n(size_t nmemb, size_t size)
178{
179 int nomem;
180
181 if (nomem) {
182 return NULL;
183 }
184 return g_malloc_n(nmemb, size);
185}
186
187void *g_try_malloc0_n(size_t nmemb, size_t size)
188{
189 int nomem;
190
191 if (nomem) {
192 return NULL;
193 }
194 return g_malloc0_n(nmemb, size);
195}
196
197void *g_try_realloc_n(void *ptr, size_t nmemb, size_t size)
198{
199 int nomem;
200
201 if (nomem) {
202 return NULL;
203 }
204 return g_realloc_n(ptr, nmemb, size);
205}
206
207
208
209void *g_malloc(size_t size)
210{
211 return g_malloc_n(1, size);
212}
213
214void *g_malloc0(size_t size)
215{
216 return g_malloc0_n(1, size);
217}
218
219void *g_realloc(void *ptr, size_t size)
220{
221 return g_realloc_n(ptr, 1, size);
222}
223
224void *g_try_malloc(size_t size)
225{
226 return g_try_malloc_n(1, size);
227}
228
229void *g_try_malloc0(size_t size)
230{
231 return g_try_malloc0_n(1, size);
232}
233
234void *g_try_realloc(void *ptr, size_t size)
235{
236 return g_try_realloc_n(ptr, 1, size);
237}
238
239
240
241
242
243char *g_strdup(const char *s)
244{
245 char *dup;
246 size_t i;
247
248 if (!s) {
249 return NULL;
250 }
251
252 __coverity_string_null_sink__(s);
253 __coverity_string_size_sink__(s);
254 dup = __coverity_alloc_nosize__();
255 __coverity_mark_as_afm_allocated__(dup, "g_free");
256 for (i = 0; (dup[i] = s[i]); i++) ;
257 return dup;
258}
259
260char *g_strndup(const char *s, size_t n)
261{
262 char *dup;
263 size_t i;
264
265 __coverity_negative_sink__(n);
266
267 if (!s) {
268 return NULL;
269 }
270
271 dup = g_malloc(n + 1);
272 for (i = 0; i < n && (dup[i] = s[i]); i++) ;
273 dup[i] = 0;
274 return dup;
275}
276
277char *g_strdup_printf(const char *format, ...)
278{
279 char ch, *s;
280 size_t len;
281
282 __coverity_string_null_sink__(format);
283 __coverity_string_size_sink__(format);
284
285 ch = *format;
286
287 s = __coverity_alloc_nosize__();
288 __coverity_writeall__(s);
289 __coverity_mark_as_afm_allocated__(s, "g_free");
290 return s;
291}
292
293char *g_strdup_vprintf(const char *format, va_list ap)
294{
295 char ch, *s;
296 size_t len;
297
298 __coverity_string_null_sink__(format);
299 __coverity_string_size_sink__(format);
300
301 ch = *format;
302 ch = *(char *)ap;
303
304 s = __coverity_alloc_nosize__();
305 __coverity_writeall__(s);
306 __coverity_mark_as_afm_allocated__(s, "g_free");
307
308 return len;
309}
310
311char *g_strconcat(const char *s, ...)
312{
313 char *s;
314
315
316
317
318
319
320 s = __coverity_alloc_nosize__();
321 __coverity_writeall__(s);
322 __coverity_mark_as_afm_allocated__(s, "g_free");
323 return s;
324}
325
326
327
328typedef struct _GIOChannel GIOChannel;
329GIOChannel *g_io_channel_unix_new(int fd)
330{
331 GIOChannel *c = g_malloc0(sizeof(GIOChannel));
332 __coverity_escape__(fd);
333 return c;
334}
335
336void g_assertion_message_expr(const char *domain,
337 const char *file,
338 int line,
339 const char *func,
340 const char *expr)
341{
342 __coverity_panic__();
343}
344