blob: 874a6da79243670de882a8482a2cffd5c0b4ff40 [file] [log] [blame]
njn5c004e42002-11-18 11:04:50 +00001
2/*--------------------------------------------------------------------*/
3/*--- Code that is shared between MemCheck and AddrCheck. ---*/
njn43c799e2003-04-08 00:08:52 +00004/*--- mac_needs.c ---*/
njn5c004e42002-11-18 11:04:50 +00005/*--------------------------------------------------------------------*/
6
7/*
8 This file is part of MemCheck, a heavyweight Valgrind skin for
9 detecting memory errors, and AddrCheck, a lightweight Valgrind skin
10 for detecting memory errors.
11
njn0e1b5142003-04-15 14:58:06 +000012 Copyright (C) 2000-2003 Julian Seward
njn5c004e42002-11-18 11:04:50 +000013 jseward@acm.org
14
15 This program is free software; you can redistribute it and/or
16 modify it under the terms of the GNU General Public License as
17 published by the Free Software Foundation; either version 2 of the
18 License, or (at your option) any later version.
19
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
28 02111-1307, USA.
29
30 The GNU General Public License is contained in the file COPYING.
31*/
32
33
njn43c799e2003-04-08 00:08:52 +000034#include "mac_shared.h"
njn5c004e42002-11-18 11:04:50 +000035
njn47363ab2003-04-21 13:24:40 +000036#include "memcheck.h" /* for VG_USERREQ__* */
37
njn5c004e42002-11-18 11:04:50 +000038/*------------------------------------------------------------*/
39/*--- Defns ---*/
40/*------------------------------------------------------------*/
41
42/* These many bytes below %ESP are considered addressible if we're
43 doing the --workaround-gcc296-bugs hack. */
44#define VG_GCC296_BUG_STACK_SLOP 1024
45
46/*------------------------------------------------------------*/
47/*--- Command line options ---*/
48/*------------------------------------------------------------*/
49
njn43c799e2003-04-08 00:08:52 +000050Bool MAC_(clo_partial_loads_ok) = True;
51Int MAC_(clo_freelist_vol) = 1000000;
52Bool MAC_(clo_leak_check) = False;
53VgRes MAC_(clo_leak_resolution) = Vg_LowRes;
54Bool MAC_(clo_show_reachable) = False;
55Bool MAC_(clo_workaround_gcc296_bugs) = False;
njn5c004e42002-11-18 11:04:50 +000056
njn43c799e2003-04-08 00:08:52 +000057Bool MAC_(process_common_cmd_line_option)(Char* arg)
njn5c004e42002-11-18 11:04:50 +000058{
njn43c799e2003-04-08 00:08:52 +000059 if (VG_CLO_STREQ(arg, "--partial-loads-ok=yes"))
60 MAC_(clo_partial_loads_ok) = True;
61 else if (VG_CLO_STREQ(arg, "--partial-loads-ok=no"))
62 MAC_(clo_partial_loads_ok) = False;
njn5c004e42002-11-18 11:04:50 +000063
njn43c799e2003-04-08 00:08:52 +000064 else if (VG_CLO_STREQN(15, arg, "--freelist-vol=")) {
65 MAC_(clo_freelist_vol) = (Int)VG_(atoll)(&arg[15]);
66 if (MAC_(clo_freelist_vol) < 0) MAC_(clo_freelist_vol) = 0;
njn5c004e42002-11-18 11:04:50 +000067 }
68
njn43c799e2003-04-08 00:08:52 +000069 else if (VG_CLO_STREQ(arg, "--leak-check=yes"))
70 MAC_(clo_leak_check) = True;
71 else if (VG_CLO_STREQ(arg, "--leak-check=no"))
72 MAC_(clo_leak_check) = False;
njn5c004e42002-11-18 11:04:50 +000073
njn43c799e2003-04-08 00:08:52 +000074 else if (VG_CLO_STREQ(arg, "--leak-resolution=low"))
75 MAC_(clo_leak_resolution) = Vg_LowRes;
76 else if (VG_CLO_STREQ(arg, "--leak-resolution=med"))
77 MAC_(clo_leak_resolution) = Vg_MedRes;
78 else if (VG_CLO_STREQ(arg, "--leak-resolution=high"))
79 MAC_(clo_leak_resolution) = Vg_HighRes;
njn5c004e42002-11-18 11:04:50 +000080
njn43c799e2003-04-08 00:08:52 +000081 else if (VG_CLO_STREQ(arg, "--show-reachable=yes"))
82 MAC_(clo_show_reachable) = True;
83 else if (VG_CLO_STREQ(arg, "--show-reachable=no"))
84 MAC_(clo_show_reachable) = False;
njn5c004e42002-11-18 11:04:50 +000085
njn43c799e2003-04-08 00:08:52 +000086 else if (VG_CLO_STREQ(arg, "--workaround-gcc296-bugs=yes"))
87 MAC_(clo_workaround_gcc296_bugs) = True;
88 else if (VG_CLO_STREQ(arg, "--workaround-gcc296-bugs=no"))
89 MAC_(clo_workaround_gcc296_bugs) = False;
njn5c004e42002-11-18 11:04:50 +000090
91 else
njn3e884182003-04-15 13:03:23 +000092 return VG_(replacement_malloc_process_cmd_line_option)(arg);
njn5c004e42002-11-18 11:04:50 +000093
94 return True;
njn43c799e2003-04-08 00:08:52 +000095}
njn5c004e42002-11-18 11:04:50 +000096
njn3e884182003-04-15 13:03:23 +000097void MAC_(print_common_usage)(void)
njn43c799e2003-04-08 00:08:52 +000098{
njn3e884182003-04-15 13:03:23 +000099 VG_(printf)(
100" --partial-loads-ok=no|yes too hard to explain here; see manual [yes]\n"
101" --freelist-vol=<number> volume of freed blocks queue [1000000]\n"
102" --leak-check=no|yes search for memory leaks at exit? [no]\n"
103" --leak-resolution=low|med|high how much bt merging in leak check [low]\n"
104" --show-reachable=no|yes show reachable blocks in leak check? [no]\n"
105" --workaround-gcc296-bugs=no|yes self explanatory [no]\n"
106 );
107 VG_(replacement_malloc_print_usage)();
njn43c799e2003-04-08 00:08:52 +0000108}
109
njn3e884182003-04-15 13:03:23 +0000110void MAC_(print_common_debug_usage)(void)
njn43c799e2003-04-08 00:08:52 +0000111{
njn3e884182003-04-15 13:03:23 +0000112 VG_(replacement_malloc_print_debug_usage)();
njn5c004e42002-11-18 11:04:50 +0000113}
114
115/*------------------------------------------------------------*/
116/*--- Comparing and printing errors ---*/
117/*------------------------------------------------------------*/
118
119static __inline__
120void clear_AddrInfo ( AddrInfo* ai )
121{
122 ai->akind = Unknown;
123 ai->blksize = 0;
124 ai->rwoffset = 0;
125 ai->lastchange = NULL;
126 ai->stack_tid = VG_INVALID_THREADID;
127 ai->maybe_gcc = False;
128}
129
njn43c799e2003-04-08 00:08:52 +0000130void MAC_(clear_MAC_Error) ( MAC_Error* err_extra )
njn5c004e42002-11-18 11:04:50 +0000131{
132 err_extra->axskind = ReadAxs;
133 err_extra->size = 0;
134 clear_AddrInfo ( &err_extra->addrinfo );
135 err_extra->isWrite = False;
136}
137
138__attribute__ ((unused))
139static Bool eq_AddrInfo ( VgRes res, AddrInfo* ai1, AddrInfo* ai2 )
140{
141 if (ai1->akind != Undescribed
142 && ai2->akind != Undescribed
143 && ai1->akind != ai2->akind)
144 return False;
145 if (ai1->akind == Freed || ai1->akind == Mallocd) {
146 if (ai1->blksize != ai2->blksize)
147 return False;
148 if (!VG_(eq_ExeContext)(res, ai1->lastchange, ai2->lastchange))
149 return False;
150 }
151 return True;
152}
153
154/* Compare error contexts, to detect duplicates. Note that if they
155 are otherwise the same, the faulting addrs and associated rwoffsets
156 are allowed to be different. */
157
158Bool SK_(eq_SkinError) ( VgRes res, Error* e1, Error* e2 )
159{
njn43c799e2003-04-08 00:08:52 +0000160 MAC_Error* e1_extra = VG_(get_error_extra)(e1);
161 MAC_Error* e2_extra = VG_(get_error_extra)(e2);
njn7cc53a82002-11-19 16:19:32 +0000162
163 /* Guaranteed by calling function */
164 sk_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));
njn5c004e42002-11-18 11:04:50 +0000165
166 switch (VG_(get_error_kind)(e1)) {
167 case CoreMemErr: {
168 Char *e1s, *e2s;
169 if (e1_extra->isWrite != e2_extra->isWrite) return False;
njn5c004e42002-11-18 11:04:50 +0000170 e1s = VG_(get_error_string)(e1);
171 e2s = VG_(get_error_string)(e2);
172 if (e1s == e2s) return True;
173 if (0 == VG_(strcmp)(e1s, e2s)) return True;
174 return False;
175 }
176
177 case UserErr:
178 case ParamErr:
179 if (e1_extra->isWrite != e2_extra->isWrite) return False;
180 if (VG_(get_error_kind)(e1) == ParamErr
181 && 0 != VG_(strcmp)(VG_(get_error_string)(e1),
182 VG_(get_error_string)(e2))) return False;
183 return True;
184
185 case FreeErr:
186 case FreeMismatchErr:
187 /* JRS 2002-Aug-26: comparing addrs seems overkill and can
188 cause excessive duplication of errors. Not even AddrErr
189 below does that. So don't compare either the .addr field
190 or the .addrinfo fields. */
191 /* if (e1->addr != e2->addr) return False; */
192 /* if (!eq_AddrInfo(res, &e1_extra->addrinfo, &e2_extra->addrinfo))
193 return False;
194 */
195 return True;
196
197 case AddrErr:
198 /* if (e1_extra->axskind != e2_extra->axskind) return False; */
199 if (e1_extra->size != e2_extra->size) return False;
200 /*
201 if (!eq_AddrInfo(res, &e1_extra->addrinfo, &e2_extra->addrinfo))
202 return False;
203 */
204 return True;
205
206 case ValueErr:
207 if (e1_extra->size != e2_extra->size) return False;
208 return True;
209
njn34419c12003-05-02 17:24:29 +0000210 case OverlapErr:
211 return True;
212
njn43c799e2003-04-08 00:08:52 +0000213 case LeakErr:
214 VG_(skin_panic)("Shouldn't get LeakErr in SK_(eq_SkinError),\n"
215 "since it's handled with VG_(unique_error)()!");
216
njn5c004e42002-11-18 11:04:50 +0000217 default:
218 VG_(printf)("Error:\n unknown error code %d\n",
219 VG_(get_error_kind)(e1));
220 VG_(skin_panic)("unknown error code in SK_(eq_SkinError)");
221 }
222}
223
njn43c799e2003-04-08 00:08:52 +0000224void MAC_(pp_AddrInfo) ( Addr a, AddrInfo* ai )
njn5c004e42002-11-18 11:04:50 +0000225{
226 switch (ai->akind) {
227 case Stack:
228 VG_(message)(Vg_UserMsg,
229 " Address 0x%x is on thread %d's stack",
230 a, ai->stack_tid);
231 break;
232 case Unknown:
233 if (ai->maybe_gcc) {
234 VG_(message)(Vg_UserMsg,
235 " Address 0x%x is just below %%esp. Possibly a bug in GCC/G++",
236 a);
237 VG_(message)(Vg_UserMsg,
238 " v 2.96 or 3.0.X. To suppress, use: --workaround-gcc296-bugs=yes");
239 } else {
240 VG_(message)(Vg_UserMsg,
241 " Address 0x%x is not stack'd, malloc'd or free'd", a);
242 }
243 break;
sewardja81709d2002-12-28 12:55:48 +0000244 case Freed: case Mallocd: case UserG: {
njn5c004e42002-11-18 11:04:50 +0000245 UInt delta;
246 UChar* relative;
247 if (ai->rwoffset < 0) {
248 delta = (UInt)(- ai->rwoffset);
249 relative = "before";
250 } else if (ai->rwoffset >= ai->blksize) {
251 delta = ai->rwoffset - ai->blksize;
252 relative = "after";
253 } else {
254 delta = ai->rwoffset;
255 relative = "inside";
256 }
sewardja81709d2002-12-28 12:55:48 +0000257 VG_(message)(Vg_UserMsg,
258 " Address 0x%x is %d bytes %s a block of size %d %s",
259 a, delta, relative,
260 ai->blksize,
261 ai->akind==Mallocd ? "alloc'd"
262 : ai->akind==Freed ? "free'd"
263 : "client-defined");
njn5c004e42002-11-18 11:04:50 +0000264 VG_(pp_ExeContext)(ai->lastchange);
265 break;
266 }
267 default:
njn43c799e2003-04-08 00:08:52 +0000268 VG_(skin_panic)("MAC_(pp_AddrInfo)");
269 }
270}
271
272/* This prints out the message for the error types where Memcheck and
273 Addrcheck have identical messages */
274void MAC_(pp_shared_SkinError) ( Error* err )
275{
276 MAC_Error* err_extra = VG_(get_error_extra)(err);
277
278 switch (VG_(get_error_kind)(err)) {
279 case FreeErr:
280 VG_(message)(Vg_UserMsg,"Invalid free() / delete / delete[]");
281 /* fall through */
282 case FreeMismatchErr:
283 if (VG_(get_error_kind)(err) == FreeMismatchErr)
284 VG_(message)(Vg_UserMsg,
285 "Mismatched free() / delete / delete []");
286 VG_(pp_ExeContext)( VG_(get_error_where)(err) );
287 MAC_(pp_AddrInfo)(VG_(get_error_address)(err), &err_extra->addrinfo);
288 break;
289
290 case LeakErr: {
291 /* Totally abusing the types of these spare fields... oh well. */
292 UInt n_this_record = (UInt)VG_(get_error_address)(err);
293 UInt n_total_records = (UInt)VG_(get_error_string) (err);
294
295 MAC_(pp_LeakError)(err_extra, n_this_record, n_total_records);
296 break;
297 }
298
299 default:
300 VG_(printf)("Error:\n unknown Memcheck/Addrcheck error code %d\n",
301 VG_(get_error_kind)(err));
302 VG_(skin_panic)("unknown error code in MAC_(pp_shared_SkinError)");
njn5c004e42002-11-18 11:04:50 +0000303 }
304}
305
306/*------------------------------------------------------------*/
307/*--- Recording errors ---*/
308/*------------------------------------------------------------*/
309
njn43c799e2003-04-08 00:08:52 +0000310/* Additional description function for describe_addr(); used by
311 MemCheck for user blocks, which Addrcheck doesn't support. */
312Bool (*MAC_(describe_addr_supp)) ( Addr a, AddrInfo* ai ) = NULL;
313
njn43c799e2003-04-08 00:08:52 +0000314/* Describe an address as best you can, for error messages,
315 putting the result in ai. */
316static void describe_addr ( Addr a, AddrInfo* ai )
317{
njn3e884182003-04-15 13:03:23 +0000318 MAC_Chunk* sc;
319 ThreadId tid;
njn43c799e2003-04-08 00:08:52 +0000320
321 /* Nested functions, yeah. Need the lexical scoping of 'a'. */
njn3e884182003-04-15 13:03:23 +0000322
njn43c799e2003-04-08 00:08:52 +0000323 /* Closure for searching thread stacks */
324 Bool addr_is_in_bounds(Addr stack_min, Addr stack_max)
325 {
326 return (stack_min <= a && a <= stack_max);
327 }
njn3e884182003-04-15 13:03:23 +0000328 /* Closure for searching free'd list */
329 Bool addr_is_in_MAC_Chunk(MAC_Chunk* mc)
njn43c799e2003-04-08 00:08:52 +0000330 {
njn3e884182003-04-15 13:03:23 +0000331 return VG_(addr_is_in_block)( a, mc->data, mc->size );
332 }
333 /* Closure for searching malloc'd lists */
334 Bool addr_is_in_HashNode(VgHashNode* sh_ch)
335 {
336 return addr_is_in_MAC_Chunk( (MAC_Chunk*)sh_ch );
njn43c799e2003-04-08 00:08:52 +0000337 }
338
339 /* Perhaps it's a user-def'd block ? (only check if requested, though) */
340 if (NULL != MAC_(describe_addr_supp)) {
341 if (MAC_(describe_addr_supp)( a, ai ))
342 return;
343 }
344 /* Perhaps it's on a thread's stack? */
345 tid = VG_(first_matching_thread_stack)(addr_is_in_bounds);
346 if (tid != VG_INVALID_THREADID) {
347 ai->akind = Stack;
348 ai->stack_tid = tid;
349 return;
350 }
351 /* Search for a recently freed block which might bracket it. */
njn3e884182003-04-15 13:03:23 +0000352 sc = MAC_(first_matching_freed_MAC_Chunk)(addr_is_in_MAC_Chunk);
353 if (NULL != sc) {
njn43c799e2003-04-08 00:08:52 +0000354 ai->akind = Freed;
njn3e884182003-04-15 13:03:23 +0000355 ai->blksize = sc->size;
356 ai->rwoffset = (Int)a - (Int)sc->data;
357 ai->lastchange = sc->where;
njn43c799e2003-04-08 00:08:52 +0000358 return;
359 }
360 /* Search for a currently malloc'd block which might bracket it. */
njn3e884182003-04-15 13:03:23 +0000361 sc = (MAC_Chunk*)VG_(HT_first_match)(MAC_(malloc_list), addr_is_in_HashNode);
njn43c799e2003-04-08 00:08:52 +0000362 if (NULL != sc) {
363 ai->akind = Mallocd;
njn3e884182003-04-15 13:03:23 +0000364 ai->blksize = sc->size;
365 ai->rwoffset = (Int)(a) - (Int)sc->data;
366 ai->lastchange = sc->where;
njn43c799e2003-04-08 00:08:52 +0000367 return;
368 }
369 /* Clueless ... */
370 ai->akind = Unknown;
371 return;
372}
373
njn5c004e42002-11-18 11:04:50 +0000374/* Is this address within some small distance below %ESP? Used only
375 for the --workaround-gcc296-bugs kludge. */
376static Bool is_just_below_ESP( Addr esp, Addr aa )
377{
378 if ((UInt)esp > (UInt)aa
379 && ((UInt)esp - (UInt)aa) <= VG_GCC296_BUG_STACK_SLOP)
380 return True;
381 else
382 return False;
383}
384
385/* This one called from generated code. */
386
njn43c799e2003-04-08 00:08:52 +0000387void MAC_(record_address_error) ( Addr a, Int size, Bool isWrite )
njn5c004e42002-11-18 11:04:50 +0000388{
njn43c799e2003-04-08 00:08:52 +0000389 MAC_Error err_extra;
390 Bool just_below_esp;
njn5c004e42002-11-18 11:04:50 +0000391
392 just_below_esp = is_just_below_ESP( VG_(get_stack_pointer)(), a );
393
394 /* If this is caused by an access immediately below %ESP, and the
395 user asks nicely, we just ignore it. */
njn43c799e2003-04-08 00:08:52 +0000396 if (MAC_(clo_workaround_gcc296_bugs) && just_below_esp)
njn5c004e42002-11-18 11:04:50 +0000397 return;
398
njn43c799e2003-04-08 00:08:52 +0000399 MAC_(clear_MAC_Error)( &err_extra );
njn5c004e42002-11-18 11:04:50 +0000400 err_extra.axskind = isWrite ? WriteAxs : ReadAxs;
401 err_extra.size = size;
402 err_extra.addrinfo.akind = Undescribed;
403 err_extra.addrinfo.maybe_gcc = just_below_esp;
404 VG_(maybe_record_error)( NULL, AddrErr, a, /*s*/NULL, &err_extra );
405}
406
407/* These ones are called from non-generated code */
408
409/* This is for memory errors in pthread functions, as opposed to pthread API
410 errors which are found by the core. */
njn43c799e2003-04-08 00:08:52 +0000411void MAC_(record_core_mem_error) ( ThreadState* tst, Bool isWrite, Char* msg )
njn5c004e42002-11-18 11:04:50 +0000412{
njn43c799e2003-04-08 00:08:52 +0000413 MAC_Error err_extra;
njn5c004e42002-11-18 11:04:50 +0000414
njn43c799e2003-04-08 00:08:52 +0000415 MAC_(clear_MAC_Error)( &err_extra );
njn5c004e42002-11-18 11:04:50 +0000416 err_extra.isWrite = isWrite;
417 VG_(maybe_record_error)( tst, CoreMemErr, /*addr*/0, msg, &err_extra );
418}
419
njn43c799e2003-04-08 00:08:52 +0000420void MAC_(record_param_error) ( ThreadState* tst, Addr a, Bool isWrite,
njn5c004e42002-11-18 11:04:50 +0000421 Char* msg )
422{
njn43c799e2003-04-08 00:08:52 +0000423 MAC_Error err_extra;
njn5c004e42002-11-18 11:04:50 +0000424
425 sk_assert(NULL != tst);
njn43c799e2003-04-08 00:08:52 +0000426 MAC_(clear_MAC_Error)( &err_extra );
njn5c004e42002-11-18 11:04:50 +0000427 err_extra.addrinfo.akind = Undescribed;
428 err_extra.isWrite = isWrite;
429 VG_(maybe_record_error)( tst, ParamErr, a, msg, &err_extra );
430}
431
njn43c799e2003-04-08 00:08:52 +0000432void MAC_(record_jump_error) ( ThreadState* tst, Addr a )
njn5c004e42002-11-18 11:04:50 +0000433{
njn43c799e2003-04-08 00:08:52 +0000434 MAC_Error err_extra;
njn5c004e42002-11-18 11:04:50 +0000435
436 sk_assert(NULL != tst);
437
njn43c799e2003-04-08 00:08:52 +0000438 MAC_(clear_MAC_Error)( &err_extra );
njn5c004e42002-11-18 11:04:50 +0000439 err_extra.axskind = ExecAxs;
440 err_extra.addrinfo.akind = Undescribed;
441 VG_(maybe_record_error)( tst, AddrErr, a, /*s*/NULL, &err_extra );
442}
443
njn43c799e2003-04-08 00:08:52 +0000444void MAC_(record_free_error) ( ThreadState* tst, Addr a )
njn5c004e42002-11-18 11:04:50 +0000445{
njn43c799e2003-04-08 00:08:52 +0000446 MAC_Error err_extra;
njn5c004e42002-11-18 11:04:50 +0000447
448 sk_assert(NULL != tst);
449
njn43c799e2003-04-08 00:08:52 +0000450 MAC_(clear_MAC_Error)( &err_extra );
njn5c004e42002-11-18 11:04:50 +0000451 err_extra.addrinfo.akind = Undescribed;
452 VG_(maybe_record_error)( tst, FreeErr, a, /*s*/NULL, &err_extra );
453}
454
njn43c799e2003-04-08 00:08:52 +0000455void MAC_(record_freemismatch_error) ( ThreadState* tst, Addr a )
njn5c004e42002-11-18 11:04:50 +0000456{
njn43c799e2003-04-08 00:08:52 +0000457 MAC_Error err_extra;
njn5c004e42002-11-18 11:04:50 +0000458
459 sk_assert(NULL != tst);
460
njn43c799e2003-04-08 00:08:52 +0000461 MAC_(clear_MAC_Error)( &err_extra );
njn5c004e42002-11-18 11:04:50 +0000462 err_extra.addrinfo.akind = Undescribed;
463 VG_(maybe_record_error)( tst, FreeMismatchErr, a, /*s*/NULL, &err_extra );
464}
465
njn43c799e2003-04-08 00:08:52 +0000466/* Updates the copy with address info if necessary (but not for LeakErrs). */
467UInt SK_(update_extra)( Error* err )
468{
469 MAC_Error* extra;
470
471 /* Don't need to return the correct size -- LeakErrs are always shown with
472 VG_(unique_error)() so they're not copied anyway. */
473 if (LeakErr == VG_(get_error_kind)(err))
474 return 0;
475
476 extra = (MAC_Error*)VG_(get_error_extra)(err);
477
478 if (extra != NULL && Undescribed == extra->addrinfo.akind) {
479 describe_addr ( VG_(get_error_address)(err), &(extra->addrinfo) );
480 }
481
482 return sizeof(MAC_Error);
483}
484
485
njn5c004e42002-11-18 11:04:50 +0000486/*------------------------------------------------------------*/
487/*--- Suppressions ---*/
488/*------------------------------------------------------------*/
489
njn43c799e2003-04-08 00:08:52 +0000490Bool MAC_(shared_recognised_suppression) ( Char* name, Supp* su )
491{
492 SuppKind skind;
493
494 if (VG_STREQ(name, "Param")) skind = ParamSupp;
495 else if (VG_STREQ(name, "CoreMem")) skind = CoreMemSupp;
496 else if (VG_STREQ(name, "Addr1")) skind = Addr1Supp;
497 else if (VG_STREQ(name, "Addr2")) skind = Addr2Supp;
498 else if (VG_STREQ(name, "Addr4")) skind = Addr4Supp;
499 else if (VG_STREQ(name, "Addr8")) skind = Addr8Supp;
500 else if (VG_STREQ(name, "Free")) skind = FreeSupp;
501 else if (VG_STREQ(name, "Leak")) skind = LeakSupp;
502 else
503 return False;
504
505 VG_(set_supp_kind)(su, skind);
506 return True;
507}
508
njn5c004e42002-11-18 11:04:50 +0000509Bool SK_(read_extra_suppression_info) ( Int fd, Char* buf, Int nBuf, Supp *su )
510{
511 Bool eof;
512
513 if (VG_(get_supp_kind)(su) == ParamSupp) {
514 eof = VG_(get_line) ( fd, buf, nBuf );
515 if (eof) return False;
516 VG_(set_supp_string)(su, VG_(strdup)(buf));
517 }
518 return True;
519}
520
sewardj99aac972002-12-26 01:53:45 +0000521Bool SK_(error_matches_suppression)(Error* err, Supp* su)
njn5c004e42002-11-18 11:04:50 +0000522{
sewardj05bcdcb2003-05-18 10:05:38 +0000523 Int su_size;
njn43c799e2003-04-08 00:08:52 +0000524 MAC_Error* err_extra = VG_(get_error_extra)(err);
525 ErrorKind ekind = VG_(get_error_kind )(err);
njn5c004e42002-11-18 11:04:50 +0000526
527 switch (VG_(get_supp_kind)(su)) {
528 case ParamSupp:
529 return (ekind == ParamErr
njn43c799e2003-04-08 00:08:52 +0000530 && VG_STREQ(VG_(get_error_string)(err),
531 VG_(get_supp_string)(su)));
njn5c004e42002-11-18 11:04:50 +0000532
533 case CoreMemSupp:
534 return (ekind == CoreMemErr
njn43c799e2003-04-08 00:08:52 +0000535 && VG_STREQ(VG_(get_error_string)(err),
536 VG_(get_supp_string)(su)));
njn5c004e42002-11-18 11:04:50 +0000537
538 case Value0Supp: su_size = 0; goto value_case;
539 case Value1Supp: su_size = 1; goto value_case;
540 case Value2Supp: su_size = 2; goto value_case;
541 case Value4Supp: su_size = 4; goto value_case;
542 case Value8Supp: su_size = 8; goto value_case;
543 value_case:
544 return (ekind == ValueErr && err_extra->size == su_size);
545
546 case Addr1Supp: su_size = 1; goto addr_case;
547 case Addr2Supp: su_size = 2; goto addr_case;
548 case Addr4Supp: su_size = 4; goto addr_case;
549 case Addr8Supp: su_size = 8; goto addr_case;
550 addr_case:
551 return (ekind == AddrErr && err_extra->size == su_size);
552
553 case FreeSupp:
554 return (ekind == FreeErr || ekind == FreeMismatchErr);
555
njn34419c12003-05-02 17:24:29 +0000556 case OverlapSupp:
557 return (ekind = OverlapErr);
558
sewardj4a19e2f2002-12-26 11:50:21 +0000559 case LeakSupp:
njn43c799e2003-04-08 00:08:52 +0000560 return (ekind == LeakErr);
sewardj4a19e2f2002-12-26 11:50:21 +0000561
njn5c004e42002-11-18 11:04:50 +0000562 default:
563 VG_(printf)("Error:\n"
564 " unknown suppression type %d\n",
565 VG_(get_supp_kind)(su));
566 VG_(skin_panic)("unknown suppression type in "
567 "SK_(error_matches_suppression)");
568 }
569}
570
njn43c799e2003-04-08 00:08:52 +0000571Char* SK_(get_error_name) ( Error* err )
572{
573 Char* s;
574 switch (VG_(get_error_kind)(err)) {
575 case ParamErr: return "Param";
576 case UserErr: return NULL; /* Can't suppress User errors */
577 case FreeMismatchErr: return "Free";
578 case FreeErr: return "Free";
579 case AddrErr:
580 switch ( ((MAC_Error*)VG_(get_error_extra)(err))->size ) {
581 case 1: return "Addr1";
582 case 2: return "Addr2";
583 case 4: return "Addr4";
584 case 8: return "Addr8";
585 default: VG_(skin_panic)("unexpected size for Addr");
586 }
587
588 case ValueErr:
589 switch ( ((MAC_Error*)VG_(get_error_extra)(err))->size ) {
590 case 0: return "Cond";
591 case 1: return "Value1";
592 case 2: return "Value2";
593 case 4: return "Value4";
594 case 8: return "Value8";
595 default: VG_(skin_panic)("unexpected size for Value");
596 }
597 case CoreMemErr: return "CoreMem";
njn34419c12003-05-02 17:24:29 +0000598 case OverlapErr: return "Overlap";
njn43c799e2003-04-08 00:08:52 +0000599 case LeakErr: return "Leak";
600 default: VG_(skin_panic)("get_error_name: unexpected type");
601 }
602 VG_(printf)(s);
603}
604
605void SK_(print_extra_suppression_info) ( Error* err )
606{
607 if (ParamErr == VG_(get_error_kind)(err)) {
608 VG_(printf)(" %s\n", VG_(get_error_string)(err));
609 }
610}
njn5c004e42002-11-18 11:04:50 +0000611
612/*------------------------------------------------------------*/
613/*--- Crude profiling machinery. ---*/
614/*------------------------------------------------------------*/
615
616/* Event index. If just the name of the fn is given, this means the
617 number of calls to the fn. Otherwise it is the specified event.
618 Ones marked 'M' are MemCheck only. Ones marked 'A' are AddrCheck only.
619 The rest are shared.
620
621 10 alloc_secondary_map
622
623 20 get_abit
624M 21 get_vbyte
625 22 set_abit
626M 23 set_vbyte
627 24 get_abits4_ALIGNED
628M 25 get_vbytes4_ALIGNED
629
630 30 set_address_range_perms
631 31 set_address_range_perms(lower byte loop)
632 32 set_address_range_perms(quadword loop)
633 33 set_address_range_perms(upper byte loop)
634
635 35 make_noaccess
636 36 make_writable
637 37 make_readable
638A 38 make_accessible
639
640 40 copy_address_range_state
641 41 copy_address_range_state(byte loop)
642 42 check_writable
643 43 check_writable(byte loop)
644 44 check_readable
645 45 check_readable(byte loop)
646 46 check_readable_asciiz
647 47 check_readable_asciiz(byte loop)
648A 48 check_accessible
649A 49 check_accessible(byte loop)
650
651 50 make_noaccess_aligned
652 51 make_writable_aligned
653
654M 60 helperc_LOADV4
655M 61 helperc_STOREV4
656M 62 helperc_LOADV2
657M 63 helperc_STOREV2
658M 64 helperc_LOADV1
659M 65 helperc_STOREV1
660
661A 66 helperc_ACCESS4
662A 67 helperc_ACCESS2
663A 68 helperc_ACCESS1
664
665M 70 rim_rd_V4_SLOWLY
666M 71 rim_wr_V4_SLOWLY
667M 72 rim_rd_V2_SLOWLY
668M 73 rim_wr_V2_SLOWLY
669M 74 rim_rd_V1_SLOWLY
670M 75 rim_wr_V1_SLOWLY
671
672A 76 ACCESS4_SLOWLY
673A 77 ACCESS2_SLOWLY
674A 78 ACCESS1_SLOWLY
675
676 80 fpu_read
677 81 fpu_read aligned 4
678 82 fpu_read aligned 8
679 83 fpu_read 2
680 84 fpu_read 10/28/108
681
682M 85 fpu_write
683M 86 fpu_write aligned 4
684M 87 fpu_write aligned 8
685M 88 fpu_write 2
686M 89 fpu_write 10/28/108
687
688 90 fpu_access
689 91 fpu_access aligned 4
690 92 fpu_access aligned 8
691 93 fpu_access 2
692 94 fpu_access 10/28/108
693
694 100 fpu_access_check_SLOWLY
695 101 fpu_access_check_SLOWLY(byte loop)
njn9b007f62003-04-07 14:40:25 +0000696
697 110 new_mem_stack_4
698 111 new_mem_stack_8
699 112 new_mem_stack_12
700 113 new_mem_stack_16
701 114 new_mem_stack_32
702 115 new_mem_stack
703
704 120 die_mem_stack_4
705 121 die_mem_stack_8
706 122 die_mem_stack_12
707 123 die_mem_stack_16
708 124 die_mem_stack_32
709 125 die_mem_stack
njn5c004e42002-11-18 11:04:50 +0000710*/
711
njn43c799e2003-04-08 00:08:52 +0000712#ifdef MAC_PROFILE_MEMORY
njn5c004e42002-11-18 11:04:50 +0000713
njn43c799e2003-04-08 00:08:52 +0000714UInt MAC_(event_ctr)[N_PROF_EVENTS];
njn5c004e42002-11-18 11:04:50 +0000715
njnb4aee052003-04-15 14:09:58 +0000716static void init_prof_mem ( void )
njn5c004e42002-11-18 11:04:50 +0000717{
718 Int i;
719 for (i = 0; i < N_PROF_EVENTS; i++)
njn43c799e2003-04-08 00:08:52 +0000720 MAC_(event_ctr)[i] = 0;
njn5c004e42002-11-18 11:04:50 +0000721}
722
njnb4aee052003-04-15 14:09:58 +0000723static void done_prof_mem ( void )
njn5c004e42002-11-18 11:04:50 +0000724{
725 Int i;
726 for (i = 0; i < N_PROF_EVENTS; i++) {
727 if ((i % 10) == 0)
728 VG_(printf)("\n");
njn43c799e2003-04-08 00:08:52 +0000729 if (MAC_(event_ctr)[i] > 0)
730 VG_(printf)( "prof mem event %2d: %d\n", i, MAC_(event_ctr)[i] );
njn5c004e42002-11-18 11:04:50 +0000731 }
732 VG_(printf)("\n");
733}
734
735#else
736
njnb4aee052003-04-15 14:09:58 +0000737static void init_prof_mem ( void ) { }
738static void done_prof_mem ( void ) { }
njn5c004e42002-11-18 11:04:50 +0000739
njn5c004e42002-11-18 11:04:50 +0000740#endif
741
742/*------------------------------------------------------------*/
njn3e884182003-04-15 13:03:23 +0000743/*--- Common initialisation + finalisation ---*/
744/*------------------------------------------------------------*/
745
746void MAC_(common_pre_clo_init)(void)
747{
748 MAC_(malloc_list) = VG_(HT_construct)();
749 init_prof_mem();
750}
751
752void MAC_(common_fini)(void (*leak_check)(void))
753{
754 MAC_(print_malloc_stats)();
755
756 if (VG_(clo_verbosity) == 1) {
757 if (!MAC_(clo_leak_check))
758 VG_(message)(Vg_UserMsg,
759 "For a detailed leak analysis, rerun with: --leak-check=yes");
760
761 VG_(message)(Vg_UserMsg,
762 "For counts of detected errors, rerun with: -v");
763 }
764 if (MAC_(clo_leak_check)) leak_check();
765
766 done_prof_mem();
767}
768
769/*------------------------------------------------------------*/
njn47363ab2003-04-21 13:24:40 +0000770/*--- Common client request handling ---*/
771/*------------------------------------------------------------*/
772
773Bool MAC_(handle_common_client_requests)(ThreadState* tst, UInt* arg,
774 UInt* ret )
775{
776 UInt** argp = (UInt**)arg;
777
778 switch (arg[0]) {
779 case VG_USERREQ__COUNT_LEAKS: /* count leaked bytes */
780 *argp[1] = MAC_(total_bytes_leaked);
781 *argp[2] = MAC_(total_bytes_dubious);
782 *argp[3] = MAC_(total_bytes_reachable);
783 *argp[4] = MAC_(total_bytes_suppressed);
784 *ret = 0;
785 return True;
786
787 default:
788 return False;
789 }
790}
791
792/*------------------------------------------------------------*/
njn5c004e42002-11-18 11:04:50 +0000793/*--- Syscall wrappers ---*/
794/*------------------------------------------------------------*/
795
796void* SK_(pre_syscall) ( ThreadId tid, UInt syscallno, Bool isBlocking )
797{
798 Int sane = SK_(cheap_sanity_check)();
799 return (void*)sane;
800}
801
802void SK_(post_syscall) ( ThreadId tid, UInt syscallno,
803 void* pre_result, Int res, Bool isBlocking )
804{
805 Int sane_before_call = (Int)pre_result;
806 Bool sane_after_call = SK_(cheap_sanity_check)();
807
808 if ((Int)sane_before_call && (!sane_after_call)) {
809 VG_(message)(Vg_DebugMsg, "post-syscall: ");
810 VG_(message)(Vg_DebugMsg,
811 "probable sanity check failure for syscall number %d\n",
812 syscallno );
813 VG_(skin_panic)("aborting due to the above ... bye!");
814 }
815}
816
njn5c004e42002-11-18 11:04:50 +0000817/*--------------------------------------------------------------------*/
njn43c799e2003-04-08 00:08:52 +0000818/*--- end mac_needs.c ---*/
njn5c004e42002-11-18 11:04:50 +0000819/*--------------------------------------------------------------------*/