memcheck/mc_include.h

   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:
  50 extern SizeT MC_(Malloc_Redzone_SzB);
  51
  52 /* For malloc()/new/new[] vs. free()/delete/delete[] mismatch checking. */
  53 typedef
  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. */
  64 typedef
  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). */
  79 ExeContext* MC_(allocated_at) (MC_Chunk*);
  80 ExeContext* MC_(freed_at) (MC_Chunk*);
  81
  82 /* Records and sets execontext according to MC_(clo_keep_stacktraces) */
  83 void  MC_(set_allocated_at) (ThreadId, MC_Chunk*);
  84 void  MC_(set_freed_at) (ThreadId, MC_Chunk*);
  85
  86 /* number of pointers needed according to MC_(clo_keep_stacktraces). */
  87 UInt MC_(n_where_pointers) (void);
  88
  89 /* Memory pool.  Nb: first two fields must match core's VgHashNode. */
  90 typedef
  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
 101 void* MC_(new_block)  ( ThreadId tid,
 102                         Addr p, SizeT size, SizeT align,
 103                         Bool is_zeroed, MC_AllocKind kind,
 104                         VgHashTable *table);
 105 void MC_(handle_free) ( ThreadId tid,
 106                         Addr p, UInt rzB, MC_AllocKind kind );
 107
 108 void MC_(create_mempool)  ( Addr pool, UInt rzB, Bool is_zeroed );
 109 void MC_(destroy_mempool) ( Addr pool );
 110 void MC_(mempool_alloc)   ( ThreadId tid, Addr pool,
 111                             Addr addr, SizeT size );
 112 void MC_(mempool_free)    ( Addr pool, Addr addr );
 113 void MC_(mempool_trim)    ( Addr pool, Addr addr, SizeT size );
 114 void MC_(move_mempool)    ( Addr poolA, Addr poolB );
 115 void MC_(mempool_change)  ( Addr pool, Addr addrA, Addr addrB, SizeT size );
 116 Bool 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. */
 121 MC_Chunk* MC_(get_freed_block_bracketting)( Addr a );
 122
 123 /* For efficient pooled alloc/free of the MC_Chunk. */
 124 extern 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. */
 130 extern VgHashTable *MC_(malloc_list);
 131
 132 /* For tracking memory pools. */
 133 extern VgHashTable *MC_(mempool_list);
 134
 135 /* Shadow memory functions */
 136 Bool MC_(check_mem_is_noaccess)( Addr a, SizeT len, Addr* bad_addr );
 137 void MC_(make_mem_noaccess)        ( Addr a, SizeT len );
 138 void MC_(make_mem_undefined_w_otag)( Addr a, SizeT len, UInt otag );
 139 void MC_(make_mem_defined)         ( Addr a, SizeT len );
 140 void MC_(copy_address_range_state) ( Addr src, Addr dst, SizeT len );
 141
 142 void MC_(print_malloc_stats) ( void );
 143 /* nr of free operations done */
 144 SizeT MC_(get_cmalloc_n_frees) ( void );
 145
 146 void* MC_(malloc)               ( ThreadId tid, SizeT n );
 147 void* MC_(__builtin_new)        ( ThreadId tid, SizeT n );
 148 void* MC_(__builtin_vec_new)    ( ThreadId tid, SizeT n );
 149 void* MC_(memalign)             ( ThreadId tid, SizeT align, SizeT n );
 150 void* MC_(calloc)               ( ThreadId tid, SizeT nmemb, SizeT size1 );
 151 void  MC_(free)                 ( ThreadId tid, void* p );
 152 void  MC_(__builtin_delete)     ( ThreadId tid, void* p );
 153 void  MC_(__builtin_vec_delete) ( ThreadId tid, void* p );
 154 void* MC_(realloc)              ( ThreadId tid, void* p, SizeT new_size );
 155 SizeT MC_(malloc_usable_size)   ( ThreadId tid, void* p );
 156
 157 void 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. */
 166 Int MC_(get_otrack_shadow_offset) ( Int offset, Int szB );
 167 IRType 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
 214 UInt   MC_(event_ctr)[N_PROF_EVENTS];
 215 HChar* 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
 264 typedef
 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
 283 UInt MC_(all_Reachedness)(void);
 284
 285 /* For VALGRIND_COUNT_LEAKS client request */
 286 extern SizeT MC_(bytes_leaked);
 287 extern SizeT MC_(bytes_indirect);
 288 extern SizeT MC_(bytes_dubious);
 289 extern SizeT MC_(bytes_reachable);
 290 extern SizeT MC_(bytes_suppressed);
 291
 292 /* For VALGRIND_COUNT_LEAK_BLOCKS client request */
 293 extern SizeT MC_(blocks_leaked);
 294 extern SizeT MC_(blocks_indirect);
 295 extern SizeT MC_(blocks_dubious);
 296 extern SizeT MC_(blocks_reachable);
 297 extern SizeT MC_(blocks_suppressed);
 298
 299 typedef
 300    enum {
 301       LC_Off,
 302       LC_Summary,
 303       LC_Full,
 304    }
 305    LeakCheckMode;
 306
 307 typedef
 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. */
 317 typedef
 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). */
 327 typedef
 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
 339 typedef
 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
 351 void 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.
 355 extern UInt MC_(leak_search_gen);
 356
 357 // maintains the lcp.deltamode given in the last call to detect_memory_leaks
 358 extern 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.
 363 Bool 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.
 367 void 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)"
 371 extern HChar * MC_(snprintf_delta) (HChar * buf, Int size,
 372                                     SizeT current_val, SizeT old_val,
 373                                     LeakCheckDeltaMode delta_mode);
 374
 375
 376 Bool MC_(is_valid_aligned_word)     ( Addr a );
 377 Bool MC_(is_within_valid_secondary) ( Addr a );
 378
 379 // Prints as user msg a description of the given loss record.
 380 void 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. */
 392 extern Bool MC_(any_value_errors);
 393
 394 /* Standard functions for error and suppressions as required by the
 395    core/tool iface */
 396 Bool MC_(eq_Error)           ( VgRes res, const Error* e1, const Error* e2 );
 397 void MC_(before_pp_Error)    ( const Error* err );
 398 void MC_(pp_Error)           ( const Error* err );
 399 UInt MC_(update_Error_extra) ( const Error* err );
 400
 401 Bool MC_(is_recognised_suppression) ( const HChar* name, Supp* su );
 402
 403 Bool MC_(read_extra_suppression_info) ( Int fd, HChar** buf,
 404                                         SizeT* nBuf, Int* lineno, Supp *su );
 405
 406 Bool MC_(error_matches_suppression) ( const Error* err, const Supp* su );
 407
 408 SizeT MC_(get_extra_suppression_info) ( const Error* err,
 409                                         /*OUT*/HChar* buf, Int nBuf );
 410 SizeT MC_(print_extra_suppression_use) ( const Supp* su,
 411                                          /*OUT*/HChar* buf, Int nBuf );
 412 void MC_(update_extra_suppression_use) ( const Error* err, const Supp* su );
 413
 414 const HChar* MC_(get_error_name) ( const Error* err );
 415
 416 /* Recording of errors */
 417 void MC_(record_address_error) ( ThreadId tid, Addr a, Int szB,
 418                                  Bool isWrite );
 419 void MC_(record_cond_error)    ( ThreadId tid, UInt otag );
 420 void MC_(record_value_error)   ( ThreadId tid, Int szB, UInt otag );
 421 void MC_(record_jump_error)    ( ThreadId tid, Addr a );
 422
 423 void MC_(record_free_error)            ( ThreadId tid, Addr a );
 424 void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a );
 425 void MC_(record_freemismatch_error)    ( ThreadId tid, MC_Chunk* mc );
 426
 427 void MC_(record_overlap_error)  ( ThreadId tid, const HChar* function,
 428                                   Addr src, Addr dst, SizeT szB );
 429 void MC_(record_core_mem_error) ( ThreadId tid, const HChar* msg );
 430 void MC_(record_regparam_error) ( ThreadId tid, const HChar* msg, UInt otag );
 431 void MC_(record_memparam_error) ( ThreadId tid, Addr a,
 432                                   Bool isAddrErr, const HChar* msg, UInt otag );
 433 void MC_(record_user_error)     ( ThreadId tid, Addr a,
 434                                   Bool isAddrErr, UInt otag );
 435
 436 Bool 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
 443 Bool 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). */
 447 extern const HChar* MC_(parse_leak_kinds_tokens);
 448
 449 /* prints a description of address a */
 450 void MC_(pp_describe_addr) (Addr a);
 451
 452 /* Is this address in a user-specified "ignored range" ? */
 453 Bool 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.  */
 462 typedef
 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. */
 472 void 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 */
 481 extern Bool MC_(clo_partial_loads_ok);
 482
 483 /* Max volume of the freed blocks queue. */
 484 extern 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. */
 488 extern Long MC_(clo_freelist_big_blocks);
 489
 490 /* Do leak check at exit?  default: NO */
 491 extern LeakCheckMode MC_(clo_leak_check);
 492
 493 /* How closely should we compare ExeContexts in leak records? default: 2 */
 494 extern 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). */
 498 extern 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). */
 502 extern UInt MC_(clo_errors_for_leak_kinds);
 503
 504 /* Various leak check heuristics which can be activated/deactivated. */
 505 typedef
 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. */
 537 extern UInt MC_(clo_leak_check_heuristics);
 538
 539 /* Assume accesses immediately below %esp are due to gcc-2.96 bugs.
 540  * default: NO */
 541 extern 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. */
 549 extern Int MC_(clo_malloc_fill);
 550 extern 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). */
 555 typedef
 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;
 564 extern 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 */
 589 extern Int MC_(clo_mc_level);
 590
 591 /* Should we show mismatched frees?  Default: YES */
 592 extern 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. */
 605 VG_REGPARM(2) void MC_(helperc_value_checkN_fail_w_o) ( HWord, UWord );
 606 VG_REGPARM(1) void MC_(helperc_value_check8_fail_w_o) ( UWord );
 607 VG_REGPARM(1) void MC_(helperc_value_check4_fail_w_o) ( UWord );
 608 VG_REGPARM(1) void MC_(helperc_value_check1_fail_w_o) ( UWord );
 609 VG_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. */
 613 VG_REGPARM(1) void MC_(helperc_value_checkN_fail_no_o) ( HWord );
 614 VG_REGPARM(0) void MC_(helperc_value_check8_fail_no_o) ( void );
 615 VG_REGPARM(0) void MC_(helperc_value_check4_fail_no_o) ( void );
 616 VG_REGPARM(0) void MC_(helperc_value_check1_fail_no_o) ( void );
 617 VG_REGPARM(0) void MC_(helperc_value_check0_fail_no_o) ( void );
 618
 619 /* V-bits load/store helpers */
 620 VG_REGPARM(1) void MC_(helperc_STOREV64be) ( Addr, ULong );
 621 VG_REGPARM(1) void MC_(helperc_STOREV64le) ( Addr, ULong );
 622 VG_REGPARM(2) void MC_(helperc_STOREV32be) ( Addr, UWord );
 623 VG_REGPARM(2) void MC_(helperc_STOREV32le) ( Addr, UWord );
 624 VG_REGPARM(2) void MC_(helperc_STOREV16be) ( Addr, UWord );
 625 VG_REGPARM(2) void MC_(helperc_STOREV16le) ( Addr, UWord );
 626 VG_REGPARM(2) void MC_(helperc_STOREV8)    ( Addr, UWord );
 627
 628 VG_REGPARM(2) void  MC_(helperc_LOADV256be) ( /*OUT*/V256*, Addr );
 629 VG_REGPARM(2) void  MC_(helperc_LOADV256le) ( /*OUT*/V256*, Addr );
 630 VG_REGPARM(2) void  MC_(helperc_LOADV128be) ( /*OUT*/V128*, Addr );
 631 VG_REGPARM(2) void  MC_(helperc_LOADV128le) ( /*OUT*/V128*, Addr );
 632 VG_REGPARM(1) ULong MC_(helperc_LOADV64be)  ( Addr );
 633 VG_REGPARM(1) ULong MC_(helperc_LOADV64le)  ( Addr );
 634 VG_REGPARM(1) UWord MC_(helperc_LOADV32be)  ( Addr );
 635 VG_REGPARM(1) UWord MC_(helperc_LOADV32le)  ( Addr );
 636 VG_REGPARM(1) UWord MC_(helperc_LOADV16be)  ( Addr );
 637 VG_REGPARM(1) UWord MC_(helperc_LOADV16le)  ( Addr );
 638 VG_REGPARM(1) UWord MC_(helperc_LOADV8)     ( Addr );
 639
 640 void MC_(helperc_MAKE_STACK_UNINIT) ( Addr base, UWord len,
 641                                                  Addr nia );
 642
 643 /* Origin tag load/store helpers */
 644 VG_REGPARM(2) void  MC_(helperc_b_store1) ( Addr a, UWord d32 );
 645 VG_REGPARM(2) void  MC_(helperc_b_store2) ( Addr a, UWord d32 );
 646 VG_REGPARM(2) void  MC_(helperc_b_store4) ( Addr a, UWord d32 );
 647 VG_REGPARM(2) void  MC_(helperc_b_store8) ( Addr a, UWord d32 );
 648 VG_REGPARM(2) void  MC_(helperc_b_store16)( Addr a, UWord d32 );
 649 VG_REGPARM(2) void  MC_(helperc_b_store32)( Addr a, UWord d32 );
 650 VG_REGPARM(1) UWord MC_(helperc_b_load1) ( Addr a );
 651 VG_REGPARM(1) UWord MC_(helperc_b_load2) ( Addr a );
 652 VG_REGPARM(1) UWord MC_(helperc_b_load4) ( Addr a );
 653 VG_REGPARM(1) UWord MC_(helperc_b_load8) ( Addr a );
 654 VG_REGPARM(1) UWord MC_(helperc_b_load16)( Addr a );
 655 VG_REGPARM(1) UWord MC_(helperc_b_load32)( Addr a );
 656
 657 /* Functions defined in mc_translate.c */
 658 IRSB* 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
 665 IRSB* MC_(final_tidy) ( IRSB* );
 666
 667 #endif /* ndef __MC_INCLUDE_H */
 668
 669 /*--------------------------------------------------------------------*/
 670 /*--- end                                                          ---*/
 671 /*--------------------------------------------------------------------*/