1
2/*--------------------------------------------------------------------*/
3/*--- A header file for all parts of the MemCheck tool.            ---*/
4/*---                                                 mc_include.h ---*/
5/*--------------------------------------------------------------------*/
6
7/*
8   This file is part of MemCheck, a heavyweight Valgrind tool for
9   detecting memory errors.
10
11   Copyright (C) 2000-2013 Julian Seward
12      jseward@acm.org
13
14   This program is free software; you can redistribute it and/or
15   modify it under the terms of the GNU General Public License as
16   published by the Free Software Foundation; either version 2 of the
17   License, or (at your option) any later version.
18
19   This program is distributed in the hope that it will be useful, but
20   WITHOUT ANY WARRANTY; without even the implied warranty of
21   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22   General Public License for more details.
23
24   You should have received a copy of the GNU General Public License
25   along with this program; if not, write to the Free Software
26   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27   02111-1307, USA.
28
29   The GNU General Public License is contained in the file COPYING.
30*/
31
32#ifndef __MC_INCLUDE_H
33#define __MC_INCLUDE_H
34
35#define MC_(str)    VGAPPEND(vgMemCheck_,str)
36
37
38/* This is a private header file for use only within the
39   memcheck/ directory. */
40
41/*------------------------------------------------------------*/
42/*--- Tracking the heap                                    ---*/
43/*------------------------------------------------------------*/
44
45/* By default, we want at least a 16B redzone on client heap blocks
46   for Memcheck.
47   The default can be modified by --redzone-size. */
48#define MC_MALLOC_DEFAULT_REDZONE_SZB    16
49// effective redzone, as (possibly) modified by --redzone-size:
50extern SizeT MC_(Malloc_Redzone_SzB);
51
52/* For malloc()/new/new[] vs. free()/delete/delete[] mismatch checking. */
53typedef
54   enum {
55      MC_AllocMalloc = 0,
56      MC_AllocNew    = 1,
57      MC_AllocNewVec = 2,
58      MC_AllocCustom = 3
59   }
60   MC_AllocKind;
61
62/* This describes a heap block. Nb: first two fields must match core's
63 * VgHashNode. */
64typedef
65   struct _MC_Chunk {
66      struct _MC_Chunk* next;
67      Addr         data;            // Address of the actual block.
68      SizeT        szB : (sizeof(SizeT)*8)-2; // Size requested; 30 or 62 bits.
69      MC_AllocKind allockind : 2;   // Which operation did the allocation.
70      ExeContext*  where[0];
71      /* Variable-length array. The size depends on MC_(clo_keep_stacktraces).
72         This array optionally stores the alloc and/or free stack trace. */
73   }
74   MC_Chunk;
75
76/* Returns the execontext where the MC_Chunk was allocated/freed.
77   Returns VG_(null_ExeContext)() if the execontext has not been recorded (due
78   to MC_(clo_keep_stacktraces) and/or because block not yet freed). */
79ExeContext* MC_(allocated_at) (MC_Chunk*);
80ExeContext* MC_(freed_at) (MC_Chunk*);
81
82/* Records and sets execontext according to MC_(clo_keep_stacktraces) */
83void  MC_(set_allocated_at) (ThreadId, MC_Chunk*);
84void  MC_(set_freed_at) (ThreadId, MC_Chunk*);
85
86/* number of pointers needed according to MC_(clo_keep_stacktraces). */
87UInt MC_(n_where_pointers) (void);
88
89/* Memory pool.  Nb: first two fields must match core's VgHashNode. */
90typedef
91   struct _MC_Mempool {
92      struct _MC_Mempool* next;
93      Addr          pool;           // pool identifier
94      SizeT         rzB;            // pool red-zone size
95      Bool          is_zeroed;      // allocations from this pool are zeroed
96      VgHashTable  *chunks;         // chunks associated with this pool
97   }
98   MC_Mempool;
99
100
101void* MC_(new_block)  ( ThreadId tid,
102                        Addr p, SizeT size, SizeT align,
103                        Bool is_zeroed, MC_AllocKind kind,
104                        VgHashTable *table);
105void MC_(handle_free) ( ThreadId tid,
106                        Addr p, UInt rzB, MC_AllocKind kind );
107
108void MC_(create_mempool)  ( Addr pool, UInt rzB, Bool is_zeroed );
109void MC_(destroy_mempool) ( Addr pool );
110void MC_(mempool_alloc)   ( ThreadId tid, Addr pool,
111                            Addr addr, SizeT size );
112void MC_(mempool_free)    ( Addr pool, Addr addr );
113void MC_(mempool_trim)    ( Addr pool, Addr addr, SizeT size );
114void MC_(move_mempool)    ( Addr poolA, Addr poolB );
115void MC_(mempool_change)  ( Addr pool, Addr addrA, Addr addrB, SizeT size );
116Bool MC_(mempool_exists)  ( Addr pool );
117
118/* Searches for a recently freed block which might bracket Addr a.
119   Return the MC_Chunk* for this block or NULL if no bracketting block
120   is found. */
121MC_Chunk* MC_(get_freed_block_bracketting)( Addr a );
122
123/* For efficient pooled alloc/free of the MC_Chunk. */
124extern PoolAlloc* MC_(chunk_poolalloc);
125
126/* For tracking malloc'd blocks.  Nb: it's quite important that it's a
127   VgHashTable, because VgHashTable allows duplicate keys without complaint.
128   This can occur if a user marks a malloc() block as also a custom block with
129   MALLOCLIKE_BLOCK. */
130extern VgHashTable *MC_(malloc_list);
131
132/* For tracking memory pools. */
133extern VgHashTable *MC_(mempool_list);
134
135/* Shadow memory functions */
136Bool MC_(check_mem_is_noaccess)( Addr a, SizeT len, Addr* bad_addr );
137void MC_(make_mem_noaccess)        ( Addr a, SizeT len );
138void MC_(make_mem_undefined_w_otag)( Addr a, SizeT len, UInt otag );
139void MC_(make_mem_defined)         ( Addr a, SizeT len );
140void MC_(copy_address_range_state) ( Addr src, Addr dst, SizeT len );
141
142void MC_(print_malloc_stats) ( void );
143/* nr of free operations done */
144SizeT MC_(get_cmalloc_n_frees) ( void );
145
146void* MC_(malloc)               ( ThreadId tid, SizeT n );
147void* MC_(__builtin_new)        ( ThreadId tid, SizeT n );
148void* MC_(__builtin_vec_new)    ( ThreadId tid, SizeT n );
149void* MC_(memalign)             ( ThreadId tid, SizeT align, SizeT n );
150void* MC_(calloc)               ( ThreadId tid, SizeT nmemb, SizeT size1 );
151void  MC_(free)                 ( ThreadId tid, void* p );
152void  MC_(__builtin_delete)     ( ThreadId tid, void* p );
153void  MC_(__builtin_vec_delete) ( ThreadId tid, void* p );
154void* MC_(realloc)              ( ThreadId tid, void* p, SizeT new_size );
155SizeT MC_(malloc_usable_size)   ( ThreadId tid, void* p );
156
157void MC_(handle_resizeInPlace)(ThreadId tid, Addr p,
158                               SizeT oldSizeB, SizeT newSizeB, SizeT rzB);
159
160
161/*------------------------------------------------------------*/
162/*--- Origin tracking translate-time support               ---*/
163/*------------------------------------------------------------*/
164
165/* See detailed comments in mc_machine.c. */
166Int MC_(get_otrack_shadow_offset) ( Int offset, Int szB );
167IRType MC_(get_otrack_reg_array_equiv_int_type) ( IRRegArray* arr );
168
169/* Constants which are used as the lowest 2 bits in origin tags.
170
171   An origin tag comprises an upper 30-bit ECU field and a lower 2-bit
172   'kind' field.  The ECU field is a number given out by m_execontext
173   and has a 1-1 mapping with ExeContext*s.  An ECU can be used
174   directly as an origin tag (otag), but in fact we want to put
175   additional information 'kind' field to indicate roughly where the
176   tag came from.  This helps print more understandable error messages
177   for the user -- it has no other purpose.
178
179   Hence the following 2-bit constants are needed for 'kind' field.
180
181   To summarise:
182
183   * Both ECUs and origin tags are represented as 32-bit words
184
185   * m_execontext and the core-tool interface deal purely in ECUs.
186     They have no knowledge of origin tags - that is a purely
187     Memcheck-internal matter.
188
189   * all valid ECUs have the lowest 2 bits zero and at least
190     one of the upper 30 bits nonzero (see VG_(is_plausible_ECU))
191
192   * to convert from an ECU to an otag, OR in one of the MC_OKIND_
193     constants below
194
195   * to convert an otag back to an ECU, AND it with ~3
196*/
197
198#define MC_OKIND_UNKNOWN  0  /* unknown origin */
199#define MC_OKIND_HEAP     1  /* this is a heap origin */
200#define MC_OKIND_STACK    2  /* this is a stack origin */
201#define MC_OKIND_USER     3  /* arises from user-supplied client req */
202
203
204/*------------------------------------------------------------*/
205/*--- Profiling of memory events                           ---*/
206/*------------------------------------------------------------*/
207
208/* Define to collect detailed performance info. */
209/* #define MC_PROFILE_MEMORY */
210
211#ifdef MC_PROFILE_MEMORY
212#  define N_PROF_EVENTS 500
213
214UInt   MC_(event_ctr)[N_PROF_EVENTS];
215HChar* MC_(event_ctr_name)[N_PROF_EVENTS];
216
217#  define PROF_EVENT(ev, name)                                \
218   do { tl_assert((ev) >= 0 && (ev) < N_PROF_EVENTS);         \
219        /* crude and inaccurate check to ensure the same */   \
220        /* event isn't being used with > 1 name */            \
221        if (MC_(event_ctr_name)[ev])                         \
222           tl_assert(name == MC_(event_ctr_name)[ev]);       \
223        MC_(event_ctr)[ev]++;                                \
224        MC_(event_ctr_name)[ev] = (name);                    \
225   } while (False);
226
227#else
228
229#  define PROF_EVENT(ev, name) /* */
230
231#endif   /* MC_PROFILE_MEMORY */
232
233
234/*------------------------------------------------------------*/
235/*--- V and A bits (Victoria & Albert ?)                   ---*/
236/*------------------------------------------------------------*/
237
238/* The number of entries in the primary map can be altered.  However
239   we hardwire the assumption that each secondary map covers precisely
240   64k of address space. */
241#define SM_SIZE 65536            /* DO NOT CHANGE */
242#define SM_MASK (SM_SIZE-1)      /* DO NOT CHANGE */
243
244#define V_BIT_DEFINED         0
245#define V_BIT_UNDEFINED       1
246
247#define V_BITS8_DEFINED       0
248#define V_BITS8_UNDEFINED     0xFF
249
250#define V_BITS16_DEFINED      0
251#define V_BITS16_UNDEFINED    0xFFFF
252
253#define V_BITS32_DEFINED      0
254#define V_BITS32_UNDEFINED    0xFFFFFFFF
255
256#define V_BITS64_DEFINED      0ULL
257#define V_BITS64_UNDEFINED    0xFFFFFFFFFFFFFFFFULL
258
259
260/*------------------------------------------------------------*/
261/*--- Leak checking                                        ---*/
262/*------------------------------------------------------------*/
263
264typedef
265   enum {
266      // Nb: the order is important -- it dictates the order of loss records
267      // of equal sizes.
268      Reachable    =0,  // Definitely reachable from root-set.
269      Possible     =1,  // Possibly reachable from root-set;  involves at
270                        //   least one interior-pointer along the way.
271      IndirectLeak =2,  // Leaked, but reachable from another leaked block
272                        //   (be it Unreached or IndirectLeak).
273      Unreached    =3,  // Not reached, ie. leaked.
274                        //   (At best, only reachable from itself via a cycle.)
275  }
276  Reachedness;
277
278// Build mask to check or set Reachedness r membership
279#define R2S(r) (1 << (r))
280// Reachedness r is member of the Set s ?
281#define RiS(r,s) ((s) & R2S(r))
282// Returns a set containing all Reachedness
283UInt MC_(all_Reachedness)(void);
284
285/* For VALGRIND_COUNT_LEAKS client request */
286extern SizeT MC_(bytes_leaked);
287extern SizeT MC_(bytes_indirect);
288extern SizeT MC_(bytes_dubious);
289extern SizeT MC_(bytes_reachable);
290extern SizeT MC_(bytes_suppressed);
291
292/* For VALGRIND_COUNT_LEAK_BLOCKS client request */
293extern SizeT MC_(blocks_leaked);
294extern SizeT MC_(blocks_indirect);
295extern SizeT MC_(blocks_dubious);
296extern SizeT MC_(blocks_reachable);
297extern SizeT MC_(blocks_suppressed);
298
299typedef
300   enum {
301      LC_Off,
302      LC_Summary,
303      LC_Full,
304   }
305   LeakCheckMode;
306
307typedef
308   enum {
309      LCD_Any,       // output all loss records, whatever the delta
310      LCD_Increased, // output loss records with an increase in size or blocks
311      LCD_Changed,   // output loss records with an increase or
312                     //decrease in size or blocks
313   }
314   LeakCheckDeltaMode;
315
316/* When a LossRecord is put into an OSet, these elements represent the key. */
317typedef
318   struct _LossRecordKey {
319      Reachedness  state;        // LC_Extra.state value shared by all blocks.
320      ExeContext*  allocated_at; // Where they were allocated.
321   }
322   LossRecordKey;
323
324/* A loss record, used for generating err msgs.  Multiple leaked blocks can be
325 * merged into a single loss record if they have the same state and similar
326 * enough allocation points (controlled by --leak-resolution). */
327typedef
328   struct _LossRecord {
329      LossRecordKey key;  // Key, when used in an OSet.
330      SizeT szB;          // Sum of all MC_Chunk.szB values.
331      SizeT indirect_szB; // Sum of all LC_Extra.indirect_szB values.
332      UInt  num_blocks;   // Number of blocks represented by the record.
333      SizeT old_szB;          // old_* values are the values found during the
334      SizeT old_indirect_szB; // previous leak search. old_* values are used to
335      UInt  old_num_blocks;   // output only the changed/new loss records
336   }
337   LossRecord;
338
339typedef
340   struct _LeakCheckParams {
341      LeakCheckMode mode;
342      UInt show_leak_kinds;
343      UInt errors_for_leak_kinds;
344      UInt heuristics;
345      LeakCheckDeltaMode deltamode;
346      UInt max_loss_records_output; // limit on the nr of loss records output.
347      Bool requested_by_monitor_command; // True when requested by gdb/vgdb.
348   }
349   LeakCheckParams;
350
351void MC_(detect_memory_leaks) ( ThreadId tid, LeakCheckParams * lcp);
352
353// Each time a leak search is done, the leak search generation
354// MC_(leak_search_gen) is incremented.
355extern UInt MC_(leak_search_gen);
356
357// maintains the lcp.deltamode given in the last call to detect_memory_leaks
358extern LeakCheckDeltaMode MC_(detect_memory_leaks_last_delta_mode);
359
360// prints the list of blocks corresponding to the given loss_record_nr.
361// Returns True if loss_record_nr identifies a correct loss record from last
362// leak search, returns False otherwise.
363Bool MC_(print_block_list) ( UInt loss_record_nr);
364
365// Prints the addresses/registers/... at which a pointer to
366// the given range [address, address+szB[ is found.
367void MC_(who_points_at) ( Addr address, SizeT szB);
368
369// if delta_mode == LCD_Any, prints in buf an empty string
370// otherwise prints a delta in the layout  " (+%'lu)" or " (-%'lu)"
371extern HChar * MC_(snprintf_delta) (HChar * buf, Int size,
372                                    SizeT current_val, SizeT old_val,
373                                    LeakCheckDeltaMode delta_mode);
374
375
376Bool MC_(is_valid_aligned_word)     ( Addr a );
377Bool MC_(is_within_valid_secondary) ( Addr a );
378
379// Prints as user msg a description of the given loss record.
380void MC_(pp_LossRecord)(UInt n_this_record, UInt n_total_records,
381                        LossRecord* l);
382
383
384/*------------------------------------------------------------*/
385/*--- Errors and suppressions                              ---*/
386/*------------------------------------------------------------*/
387
388/* Did we show to the user, any errors for which an uninitialised
389   value origin could have been collected (but wasn't) ?  If yes,
390   then, at the end of the run, print a 1 line message advising that a
391   rerun with --track-origins=yes might help. */
392extern Bool MC_(any_value_errors);
393
394/* Standard functions for error and suppressions as required by the
395   core/tool iface */
396Bool MC_(eq_Error)           ( VgRes res, const Error* e1, const Error* e2 );
397void MC_(before_pp_Error)    ( const Error* err );
398void MC_(pp_Error)           ( const Error* err );
399UInt MC_(update_Error_extra) ( const Error* err );
400
401Bool MC_(is_recognised_suppression) ( const HChar* name, Supp* su );
402
403Bool MC_(read_extra_suppression_info) ( Int fd, HChar** buf,
404                                        SizeT* nBuf, Int* lineno, Supp *su );
405
406Bool MC_(error_matches_suppression) ( const Error* err, const Supp* su );
407
408SizeT MC_(get_extra_suppression_info) ( const Error* err,
409                                        /*OUT*/HChar* buf, Int nBuf );
410SizeT MC_(print_extra_suppression_use) ( const Supp* su,
411                                         /*OUT*/HChar* buf, Int nBuf );
412void MC_(update_extra_suppression_use) ( const Error* err, const Supp* su );
413
414const HChar* MC_(get_error_name) ( const Error* err );
415
416/* Recording of errors */
417void MC_(record_address_error) ( ThreadId tid, Addr a, Int szB,
418                                 Bool isWrite );
419void MC_(record_cond_error)    ( ThreadId tid, UInt otag );
420void MC_(record_value_error)   ( ThreadId tid, Int szB, UInt otag );
421void MC_(record_jump_error)    ( ThreadId tid, Addr a );
422
423void MC_(record_free_error)            ( ThreadId tid, Addr a );
424void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a );
425void MC_(record_freemismatch_error)    ( ThreadId tid, MC_Chunk* mc );
426
427void MC_(record_overlap_error)  ( ThreadId tid, const HChar* function,
428                                  Addr src, Addr dst, SizeT szB );
429void MC_(record_core_mem_error) ( ThreadId tid, const HChar* msg );
430void MC_(record_regparam_error) ( ThreadId tid, const HChar* msg, UInt otag );
431void MC_(record_memparam_error) ( ThreadId tid, Addr a,
432                                  Bool isAddrErr, const HChar* msg, UInt otag );
433void MC_(record_user_error)     ( ThreadId tid, Addr a,
434                                  Bool isAddrErr, UInt otag );
435
436Bool MC_(record_leak_error)     ( ThreadId tid,
437                                  UInt n_this_record,
438                                  UInt n_total_records,
439                                  LossRecord* lossRecord,
440                                  Bool print_record,
441                                  Bool count_error );
442
443Bool MC_(record_fishy_value_error)  ( ThreadId tid, const HChar* function,
444                                      const HChar *argument_name, SizeT value );
445
446/* Leak kinds tokens to call VG_(parse_enum_set). */
447extern const HChar* MC_(parse_leak_kinds_tokens);
448
449/* prints a description of address a */
450void MC_(pp_describe_addr) (Addr a);
451
452/* Is this address in a user-specified "ignored range" ? */
453Bool MC_(in_ignored_range) ( Addr a );
454
455
456/*------------------------------------------------------------*/
457/*--- Client blocks                                        ---*/
458/*------------------------------------------------------------*/
459
460/* Describes a client block.  See mc_main.c.  An unused block has
461   start == size == 0.  */
462typedef
463   struct {
464      Addr        start;
465      SizeT       size;
466      ExeContext* where;
467      HChar*      desc;
468   }
469   CGenBlock;
470
471/* Get access to the client block array. */
472void MC_(get_ClientBlock_array)( /*OUT*/CGenBlock** blocks,
473                                 /*OUT*/UWord* nBlocks );
474
475
476/*------------------------------------------------------------*/
477/*--- Command line options + defaults                      ---*/
478/*------------------------------------------------------------*/
479
480/* Allow loads from partially-valid addresses?  default: YES */
481extern Bool MC_(clo_partial_loads_ok);
482
483/* Max volume of the freed blocks queue. */
484extern Long MC_(clo_freelist_vol);
485
486/* Blocks with a size >= MC_(clo_freelist_big_blocks) will be put
487   in the "big block" freed blocks queue. */
488extern Long MC_(clo_freelist_big_blocks);
489
490/* Do leak check at exit?  default: NO */
491extern LeakCheckMode MC_(clo_leak_check);
492
493/* How closely should we compare ExeContexts in leak records? default: 2 */
494extern VgRes MC_(clo_leak_resolution);
495
496/* In leak check, show loss records if their R2S(reachedness) is set.
497   Default : R2S(Possible) | R2S(Unreached). */
498extern UInt MC_(clo_show_leak_kinds);
499
500/* In leak check, a loss record is an error if its R2S(reachedness) is set.
501   Default : R2S(Possible) | R2S(Unreached). */
502extern UInt MC_(clo_errors_for_leak_kinds);
503
504/* Various leak check heuristics which can be activated/deactivated. */
505typedef
506   enum {
507      LchNone                =0,
508      // no heuristic.
509      LchStdString           =1,
510      // Consider interior pointer pointing at the array of char in a
511      // std::string as reachable.
512      LchLength64            =2,
513      // Consider interior pointer pointing at offset 64bit of a block as
514      // reachable, when the first 8 bytes contains the block size - 8.
515      // Such length+interior pointers are used by e.g. sqlite3MemMalloc.
516      // On 64bit platforms LchNewArray will also match these blocks.
517      LchNewArray            =3,
518      // Consider interior pointer pointing at second word of a new[] array as
519      // reachable. Such interior pointers are used for arrays whose elements
520      // have a destructor.
521      LchMultipleInheritance =4,
522      // Conside interior pointer pointing just after what looks a vtable
523      // as reachable.
524  }
525  LeakCheckHeuristic;
526
527// Nr of heuristics, including the LchNone heuristic.
528#define N_LEAK_CHECK_HEURISTICS 5
529
530// Build mask to check or set Heuristic h membership
531#define H2S(h) (1 << (h))
532// Heuristic h is member of the Set s ?
533#define HiS(h,s) ((s) & H2S(h))
534
535/* Heuristics set to use for the leak search.
536   Default : no heuristic. */
537extern UInt MC_(clo_leak_check_heuristics);
538
539/* Assume accesses immediately below %esp are due to gcc-2.96 bugs.
540 * default: NO */
541extern Bool MC_(clo_workaround_gcc296_bugs);
542
543/* Fill malloc-d/free-d client blocks with a specific value?  -1 if
544   not, else 0x00 .. 0xFF indicating the fill value to use.  Can be
545   useful for causing programs with bad heap corruption to fail in
546   more repeatable ways.  Note that malloc-filled and free-filled
547   areas are still undefined and noaccess respectively.  This merely
548   causes them to contain the specified values. */
549extern Int MC_(clo_malloc_fill);
550extern Int MC_(clo_free_fill);
551
552/* Which stack trace(s) to keep for malloc'd/free'd client blocks?
553   For each client block, the stack traces where it was allocated
554   and/or freed are optionally kept depending on MC_(clo_keep_stacktraces). */
555typedef
556   enum {                 // keep alloc stack trace ?  keep free stack trace ?
557      KS_none,            // never                     never
558      KS_alloc,           // always                    never
559      KS_free,            // never                     always
560      KS_alloc_then_free, // when still malloc'd       when free'd
561      KS_alloc_and_free,  // always                    always
562   }
563   KeepStacktraces;
564extern KeepStacktraces MC_(clo_keep_stacktraces);
565
566/* Indicates the level of instrumentation/checking done by Memcheck.
567
568   1 = No undefined value checking, Addrcheck-style behaviour only:
569       only address checking is done.  This is faster but finds fewer
570       errors.  Note that although Addrcheck had 1 bit per byte
571       overhead vs the old Memcheck's 9 bits per byte, with this mode
572       and compressed V bits, no memory is saved with this mode --
573       it's still 2 bits per byte overhead.  This is a little wasteful
574       -- it could be done with 1 bit per byte -- but lets us reuse
575       the many shadow memory access functions.  Note that in this
576       mode neither the secondary V bit table nor the origin-tag cache
577       are used.
578
579   2 = Address checking and Undefined value checking are performed,
580       but origins are not tracked.  So the origin-tag cache is not
581       used in this mode.  This setting is the default and corresponds
582       to the "normal" Memcheck behaviour that has shipped for years.
583
584   3 = Address checking, undefined value checking, and origins for
585       undefined values are tracked.
586
587   The default is 2.
588*/
589extern Int MC_(clo_mc_level);
590
591/* Should we show mismatched frees?  Default: YES */
592extern Bool MC_(clo_show_mismatched_frees);
593
594
595/*------------------------------------------------------------*/
596/*--- Instrumentation                                      ---*/
597/*------------------------------------------------------------*/
598
599/* Functions defined in mc_main.c */
600
601/* For the fail_w_o functions, the UWord arg is actually the 32-bit
602   origin tag and should really be UInt, but to be simple and safe
603   considering it's called from generated code, just claim it to be a
604   UWord. */
605VG_REGPARM(2) void MC_(helperc_value_checkN_fail_w_o) ( HWord, UWord );
606VG_REGPARM(1) void MC_(helperc_value_check8_fail_w_o) ( UWord );
607VG_REGPARM(1) void MC_(helperc_value_check4_fail_w_o) ( UWord );
608VG_REGPARM(1) void MC_(helperc_value_check1_fail_w_o) ( UWord );
609VG_REGPARM(1) void MC_(helperc_value_check0_fail_w_o) ( UWord );
610
611/* And call these ones instead to report an uninitialised value error
612   but with no origin available. */
613VG_REGPARM(1) void MC_(helperc_value_checkN_fail_no_o) ( HWord );
614VG_REGPARM(0) void MC_(helperc_value_check8_fail_no_o) ( void );
615VG_REGPARM(0) void MC_(helperc_value_check4_fail_no_o) ( void );
616VG_REGPARM(0) void MC_(helperc_value_check1_fail_no_o) ( void );
617VG_REGPARM(0) void MC_(helperc_value_check0_fail_no_o) ( void );
618
619/* V-bits load/store helpers */
620VG_REGPARM(1) void MC_(helperc_STOREV64be) ( Addr, ULong );
621VG_REGPARM(1) void MC_(helperc_STOREV64le) ( Addr, ULong );
622VG_REGPARM(2) void MC_(helperc_STOREV32be) ( Addr, UWord );
623VG_REGPARM(2) void MC_(helperc_STOREV32le) ( Addr, UWord );
624VG_REGPARM(2) void MC_(helperc_STOREV16be) ( Addr, UWord );
625VG_REGPARM(2) void MC_(helperc_STOREV16le) ( Addr, UWord );
626VG_REGPARM(2) void MC_(helperc_STOREV8)    ( Addr, UWord );
627
628VG_REGPARM(2) void  MC_(helperc_LOADV256be) ( /*OUT*/V256*, Addr );
629VG_REGPARM(2) void  MC_(helperc_LOADV256le) ( /*OUT*/V256*, Addr );
630VG_REGPARM(2) void  MC_(helperc_LOADV128be) ( /*OUT*/V128*, Addr );
631VG_REGPARM(2) void  MC_(helperc_LOADV128le) ( /*OUT*/V128*, Addr );
632VG_REGPARM(1) ULong MC_(helperc_LOADV64be)  ( Addr );
633VG_REGPARM(1) ULong MC_(helperc_LOADV64le)  ( Addr );
634VG_REGPARM(1) UWord MC_(helperc_LOADV32be)  ( Addr );
635VG_REGPARM(1) UWord MC_(helperc_LOADV32le)  ( Addr );
636VG_REGPARM(1) UWord MC_(helperc_LOADV16be)  ( Addr );
637VG_REGPARM(1) UWord MC_(helperc_LOADV16le)  ( Addr );
638VG_REGPARM(1) UWord MC_(helperc_LOADV8)     ( Addr );
639
640void MC_(helperc_MAKE_STACK_UNINIT) ( Addr base, UWord len,
641                                                 Addr nia );
642
643/* Origin tag load/store helpers */
644VG_REGPARM(2) void  MC_(helperc_b_store1) ( Addr a, UWord d32 );
645VG_REGPARM(2) void  MC_(helperc_b_store2) ( Addr a, UWord d32 );
646VG_REGPARM(2) void  MC_(helperc_b_store4) ( Addr a, UWord d32 );
647VG_REGPARM(2) void  MC_(helperc_b_store8) ( Addr a, UWord d32 );
648VG_REGPARM(2) void  MC_(helperc_b_store16)( Addr a, UWord d32 );
649VG_REGPARM(2) void  MC_(helperc_b_store32)( Addr a, UWord d32 );
650VG_REGPARM(1) UWord MC_(helperc_b_load1) ( Addr a );
651VG_REGPARM(1) UWord MC_(helperc_b_load2) ( Addr a );
652VG_REGPARM(1) UWord MC_(helperc_b_load4) ( Addr a );
653VG_REGPARM(1) UWord MC_(helperc_b_load8) ( Addr a );
654VG_REGPARM(1) UWord MC_(helperc_b_load16)( Addr a );
655VG_REGPARM(1) UWord MC_(helperc_b_load32)( Addr a );
656
657/* Functions defined in mc_translate.c */
658IRSB* MC_(instrument) ( VgCallbackClosure* closure,
659                        IRSB* bb_in,
660                        const VexGuestLayout* layout,
661                        const VexGuestExtents* vge,
662                        const VexArchInfo* archinfo_host,
663                        IRType gWordTy, IRType hWordTy );
664
665IRSB* MC_(final_tidy) ( IRSB* );
666
667#endif /* ndef __MC_INCLUDE_H */
668
669/*--------------------------------------------------------------------*/
670/*--- end                                                          ---*/
671/*--------------------------------------------------------------------*/
672