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-2017 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       Bool          auto_free;      // De-alloc block frees all chunks in block
  97       Bool          metapool;       // These chunks are VALGRIND_MALLOC_LIKE
  98                                     // memory, and used as pool.
  99       VgHashTable  *chunks;         // chunks associated with this pool
 100    }
 101    MC_Mempool;
 102
 103
 104 void* MC_(new_block)  ( ThreadId tid,
 105                         Addr p, SizeT size, SizeT align,
 106                         Bool is_zeroed, MC_AllocKind kind,
 107                         VgHashTable *table);
 108 void MC_(handle_free) ( ThreadId tid,
 109                         Addr p, UInt rzB, MC_AllocKind kind );
 110
 111 void MC_(create_mempool)  ( Addr pool, UInt rzB, Bool is_zeroed,
 112                             Bool auto_free, Bool metapool );
 113 void MC_(destroy_mempool) ( Addr pool );
 114 void MC_(mempool_alloc)   ( ThreadId tid, Addr pool,
 115                             Addr addr, SizeT size );
 116 void MC_(mempool_free)    ( Addr pool, Addr addr );
 117 void MC_(mempool_trim)    ( Addr pool, Addr addr, SizeT size );
 118 void MC_(move_mempool)    ( Addr poolA, Addr poolB );
 119 void MC_(mempool_change)  ( Addr pool, Addr addrA, Addr addrB, SizeT size );
 120 Bool MC_(mempool_exists)  ( Addr pool );
 121 Bool MC_(is_mempool_block)( MC_Chunk* mc_search );
 122
 123 /* Searches for a recently freed block which might bracket Addr a.
 124    Return the MC_Chunk* for this block or NULL if no bracketting block
 125    is found. */
 126 MC_Chunk* MC_(get_freed_block_bracketting)( Addr a );
 127
 128 /* For efficient pooled alloc/free of the MC_Chunk. */
 129 extern PoolAlloc* MC_(chunk_poolalloc);
 130
 131 /* For tracking malloc'd blocks.  Nb: it's quite important that it's a
 132    VgHashTable, because VgHashTable allows duplicate keys without complaint.
 133    This can occur if a user marks a malloc() block as also a custom block with
 134    MALLOCLIKE_BLOCK. */
 135 extern VgHashTable *MC_(malloc_list);
 136
 137 /* For tracking memory pools. */
 138 extern VgHashTable *MC_(mempool_list);
 139
 140 /* Shadow memory functions */
 141 Bool MC_(check_mem_is_noaccess)( Addr a, SizeT len, Addr* bad_addr );
 142 void MC_(make_mem_noaccess)        ( Addr a, SizeT len );
 143 void MC_(make_mem_undefined_w_otag)( Addr a, SizeT len, UInt otag );
 144 void MC_(make_mem_defined)         ( Addr a, SizeT len );
 145 void MC_(copy_address_range_state) ( Addr src, Addr dst, SizeT len );
 146
 147 void MC_(xtmemory_report) ( const HChar* filename, Bool fini );
 148
 149 void MC_(print_malloc_stats) ( void );
 150 /* nr of free operations done */
 151 SizeT MC_(get_cmalloc_n_frees) ( void );
 152
 153 void* MC_(malloc)               ( ThreadId tid, SizeT n );
 154 void* MC_(__builtin_new)        ( ThreadId tid, SizeT n );
 155 void* MC_(__builtin_vec_new)    ( ThreadId tid, SizeT n );
 156 void* MC_(memalign)             ( ThreadId tid, SizeT align, SizeT n );
 157 void* MC_(calloc)               ( ThreadId tid, SizeT nmemb, SizeT size1 );
 158 void  MC_(free)                 ( ThreadId tid, void* p );
 159 void  MC_(__builtin_delete)     ( ThreadId tid, void* p );
 160 void  MC_(__builtin_vec_delete) ( ThreadId tid, void* p );
 161 void* MC_(realloc)              ( ThreadId tid, void* p, SizeT new_size );
 162 SizeT MC_(malloc_usable_size)   ( ThreadId tid, void* p );
 163
 164 void MC_(handle_resizeInPlace)(ThreadId tid, Addr p,
 165                                SizeT oldSizeB, SizeT newSizeB, SizeT rzB);
 166
 167
 168 /*------------------------------------------------------------*/
 169 /*--- Origin tracking translate-time support               ---*/
 170 /*------------------------------------------------------------*/
 171
 172 /* See detailed comments in mc_machine.c. */
 173 Int MC_(get_otrack_shadow_offset) ( Int offset, Int szB );
 174 IRType MC_(get_otrack_reg_array_equiv_int_type) ( IRRegArray* arr );
 175
 176 /* Constants which are used as the lowest 2 bits in origin tags.
 177
 178    An origin tag comprises an upper 30-bit ECU field and a lower 2-bit
 179    'kind' field.  The ECU field is a number given out by m_execontext
 180    and has a 1-1 mapping with ExeContext*s.  An ECU can be used
 181    directly as an origin tag (otag), but in fact we want to put
 182    additional information 'kind' field to indicate roughly where the
 183    tag came from.  This helps print more understandable error messages
 184    for the user -- it has no other purpose.
 185
 186    Hence the following 2-bit constants are needed for 'kind' field.
 187
 188    To summarise:
 189
 190    * Both ECUs and origin tags are represented as 32-bit words
 191
 192    * m_execontext and the core-tool interface deal purely in ECUs.
 193      They have no knowledge of origin tags - that is a purely
 194      Memcheck-internal matter.
 195
 196    * all valid ECUs have the lowest 2 bits zero and at least
 197      one of the upper 30 bits nonzero (see VG_(is_plausible_ECU))
 198
 199    * to convert from an ECU to an otag, OR in one of the MC_OKIND_
 200      constants below
 201
 202    * to convert an otag back to an ECU, AND it with ~3
 203 */
 204
 205 #define MC_OKIND_UNKNOWN  0  /* unknown origin */
 206 #define MC_OKIND_HEAP     1  /* this is a heap origin */
 207 #define MC_OKIND_STACK    2  /* this is a stack origin */
 208 #define MC_OKIND_USER     3  /* arises from user-supplied client req */
 209
 210
 211 /*------------------------------------------------------------*/
 212 /*--- Profiling of memory events                           ---*/
 213 /*------------------------------------------------------------*/
 214
 215 /* Define to collect detailed performance info. */
 216 /* #define MC_PROFILE_MEMORY */
 217 #ifdef MC_PROFILE_MEMORY
 218
 219 /* Order of enumerators does not matter. But MCPE_LAST has to be the
 220    last entry in the list as it is used as an array bound. */
 221 enum {
 222    MCPE_LOADV8,
 223    MCPE_LOADV8_SLOW1,
 224    MCPE_LOADV8_SLOW2,
 225    MCPE_LOADV16,
 226    MCPE_LOADV16_SLOW1,
 227    MCPE_LOADV16_SLOW2,
 228    MCPE_LOADV32,
 229    MCPE_LOADV32_SLOW1,
 230    MCPE_LOADV32_SLOW2,
 231    MCPE_LOADV64,
 232    MCPE_LOADV64_SLOW1,
 233    MCPE_LOADV64_SLOW2,
 234    MCPE_LOADV_128_OR_256,
 235    MCPE_LOADV_128_OR_256_SLOW_LOOP,
 236    MCPE_LOADV_128_OR_256_SLOW1,
 237    MCPE_LOADV_128_OR_256_SLOW2,
 238    MCPE_LOADVN_SLOW,
 239    MCPE_LOADVN_SLOW_LOOP,
 240    MCPE_STOREV8,
 241    MCPE_STOREV8_SLOW1,
 242    MCPE_STOREV8_SLOW2,
 243    MCPE_STOREV8_SLOW3,
 244    MCPE_STOREV8_SLOW4,
 245    MCPE_STOREV16,
 246    MCPE_STOREV16_SLOW1,
 247    MCPE_STOREV16_SLOW2,
 248    MCPE_STOREV16_SLOW3,
 249    MCPE_STOREV16_SLOW4,
 250    MCPE_STOREV32,
 251    MCPE_STOREV32_SLOW1,
 252    MCPE_STOREV32_SLOW2,
 253    MCPE_STOREV32_SLOW3,
 254    MCPE_STOREV32_SLOW4,
 255    MCPE_STOREV64,
 256    MCPE_STOREV64_SLOW1,
 257    MCPE_STOREV64_SLOW2,
 258    MCPE_STOREV64_SLOW3,
 259    MCPE_STOREV64_SLOW4,
 260    MCPE_STOREVN_SLOW,
 261    MCPE_STOREVN_SLOW_LOOP,
 262    MCPE_MAKE_ALIGNED_WORD32_UNDEFINED,
 263    MCPE_MAKE_ALIGNED_WORD32_UNDEFINED_SLOW,
 264    MCPE_MAKE_ALIGNED_WORD64_UNDEFINED,
 265    MCPE_MAKE_ALIGNED_WORD64_UNDEFINED_SLOW,
 266    MCPE_MAKE_ALIGNED_WORD32_NOACCESS,
 267    MCPE_MAKE_ALIGNED_WORD32_NOACCESS_SLOW,
 268    MCPE_MAKE_ALIGNED_WORD64_NOACCESS,
 269    MCPE_MAKE_ALIGNED_WORD64_NOACCESS_SLOW,
 270    MCPE_MAKE_MEM_NOACCESS,
 271    MCPE_MAKE_MEM_UNDEFINED,
 272    MCPE_MAKE_MEM_UNDEFINED_W_OTAG,
 273    MCPE_MAKE_MEM_DEFINED,
 274    MCPE_CHEAP_SANITY_CHECK,
 275    MCPE_EXPENSIVE_SANITY_CHECK,
 276    MCPE_COPY_ADDRESS_RANGE_STATE,
 277    MCPE_COPY_ADDRESS_RANGE_STATE_LOOP1,
 278    MCPE_COPY_ADDRESS_RANGE_STATE_LOOP2,
 279    MCPE_CHECK_MEM_IS_NOACCESS,
 280    MCPE_CHECK_MEM_IS_NOACCESS_LOOP,
 281    MCPE_IS_MEM_ADDRESSABLE,
 282    MCPE_IS_MEM_ADDRESSABLE_LOOP,
 283    MCPE_IS_MEM_DEFINED,
 284    MCPE_IS_MEM_DEFINED_LOOP,
 285    MCPE_IS_MEM_DEFINED_COMPREHENSIVE,
 286    MCPE_IS_MEM_DEFINED_COMPREHENSIVE_LOOP,
 287    MCPE_IS_DEFINED_ASCIIZ,
 288    MCPE_IS_DEFINED_ASCIIZ_LOOP,
 289    MCPE_FIND_CHUNK_FOR_OLD,
 290    MCPE_FIND_CHUNK_FOR_OLD_LOOP,
 291    MCPE_SET_ADDRESS_RANGE_PERMS,
 292    MCPE_SET_ADDRESS_RANGE_PERMS_SINGLE_SECMAP,
 293    MCPE_SET_ADDRESS_RANGE_PERMS_STARTOF_SECMAP,
 294    MCPE_SET_ADDRESS_RANGE_PERMS_MULTIPLE_SECMAPS,
 295    MCPE_SET_ADDRESS_RANGE_PERMS_DIST_SM1,
 296    MCPE_SET_ADDRESS_RANGE_PERMS_DIST_SM2,
 297    MCPE_SET_ADDRESS_RANGE_PERMS_DIST_SM1_QUICK,
 298    MCPE_SET_ADDRESS_RANGE_PERMS_DIST_SM2_QUICK,
 299    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP1A,
 300    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP1B,
 301    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP1C,
 302    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP8A,
 303    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP8B,
 304    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP64K,
 305    MCPE_SET_ADDRESS_RANGE_PERMS_LOOP64K_FREE_DIST_SM,
 306    MCPE_NEW_MEM_STACK,
 307    MCPE_NEW_MEM_STACK_4,
 308    MCPE_NEW_MEM_STACK_8,
 309    MCPE_NEW_MEM_STACK_12,
 310    MCPE_NEW_MEM_STACK_16,
 311    MCPE_NEW_MEM_STACK_32,
 312    MCPE_NEW_MEM_STACK_112,
 313    MCPE_NEW_MEM_STACK_128,
 314    MCPE_NEW_MEM_STACK_144,
 315    MCPE_NEW_MEM_STACK_160,
 316    MCPE_DIE_MEM_STACK,
 317    MCPE_DIE_MEM_STACK_4,
 318    MCPE_DIE_MEM_STACK_8,
 319    MCPE_DIE_MEM_STACK_12,
 320    MCPE_DIE_MEM_STACK_16,
 321    MCPE_DIE_MEM_STACK_32,
 322    MCPE_DIE_MEM_STACK_112,
 323    MCPE_DIE_MEM_STACK_128,
 324    MCPE_DIE_MEM_STACK_144,
 325    MCPE_DIE_MEM_STACK_160,
 326    MCPE_MAKE_STACK_UNINIT_W_O,
 327    MCPE_MAKE_STACK_UNINIT_NO_O,
 328    MCPE_MAKE_STACK_UNINIT_128_NO_O,
 329    MCPE_MAKE_STACK_UNINIT_128_NO_O_ALIGNED_16,
 330    MCPE_MAKE_STACK_UNINIT_128_NO_O_ALIGNED_8,
 331    MCPE_MAKE_STACK_UNINIT_128_NO_O_SLOWCASE,
 332    /* Do not add enumerators past this line. */
 333    MCPE_LAST
 334 };
 335
 336 extern ULong MC_(event_ctr)[MCPE_LAST];
 337
 338 #  define PROF_EVENT(ev)                           \
 339    do { tl_assert((ev) >= 0 && (ev) < MCPE_LAST);  \
 340       MC_(event_ctr)[ev]++;                        \
 341    } while (False);
 342
 343 #else
 344
 345 #  define PROF_EVENT(ev)    /* */
 346
 347 #endif   /* MC_PROFILE_MEMORY */
 348
 349
 350 /*------------------------------------------------------------*/
 351 /*--- V and A bits (Victoria & Albert ?)                   ---*/
 352 /*------------------------------------------------------------*/
 353
 354 /* The number of entries in the primary map can be altered.  However
 355    we hardwire the assumption that each secondary map covers precisely
 356    64k of address space. */
 357 #define SM_SIZE 65536            /* DO NOT CHANGE */
 358 #define SM_MASK (SM_SIZE-1)      /* DO NOT CHANGE */
 359
 360 #define V_BIT_DEFINED         0
 361 #define V_BIT_UNDEFINED       1
 362
 363 #define V_BITS8_DEFINED       0
 364 #define V_BITS8_UNDEFINED     0xFF
 365
 366 #define V_BITS16_DEFINED      0
 367 #define V_BITS16_UNDEFINED    0xFFFF
 368
 369 #define V_BITS32_DEFINED      0
 370 #define V_BITS32_UNDEFINED    0xFFFFFFFF
 371
 372 #define V_BITS64_DEFINED      0ULL
 373 #define V_BITS64_UNDEFINED    0xFFFFFFFFFFFFFFFFULL
 374
 375 /* Set to 1 to enable handwritten assembly helpers on targets for
 376    which it is supported. */
 377 #define ENABLE_ASSEMBLY_HELPERS 1
 378
 379 /* Comment the below to disable the fast case LOADV */
 380 #define PERF_FAST_LOADV         1
 381
 382 /*------------------------------------------------------------*/
 383 /*--- Leak checking                                        ---*/
 384 /*------------------------------------------------------------*/
 385
 386 typedef
 387    enum {
 388       // Nb: the order is important -- it dictates the order of loss records
 389       // of equal sizes.
 390       Reachable    =0,  // Definitely reachable from root-set.
 391       Possible     =1,  // Possibly reachable from root-set;  involves at
 392                         //   least one interior-pointer along the way.
 393       IndirectLeak =2,  // Leaked, but reachable from another leaked block
 394                         //   (be it Unreached or IndirectLeak).
 395       Unreached    =3   // Not reached, ie. leaked.
 396                         //   (At best, only reachable from itself via a cycle.)
 397   }
 398   Reachedness;
 399
 400 // Build mask to check or set Reachedness r membership
 401 #define R2S(r) (1 << (r))
 402 // Reachedness r is member of the Set s ?
 403 #define RiS(r,s) ((s) & R2S(r))
 404 // Returns a set containing all Reachedness
 405 UInt MC_(all_Reachedness)(void);
 406
 407 /* For VALGRIND_COUNT_LEAKS client request */
 408 extern SizeT MC_(bytes_leaked);
 409 extern SizeT MC_(bytes_indirect);
 410 extern SizeT MC_(bytes_dubious);
 411 extern SizeT MC_(bytes_reachable);
 412 extern SizeT MC_(bytes_suppressed);
 413
 414 /* For VALGRIND_COUNT_LEAK_BLOCKS client request */
 415 extern SizeT MC_(blocks_leaked);
 416 extern SizeT MC_(blocks_indirect);
 417 extern SizeT MC_(blocks_dubious);
 418 extern SizeT MC_(blocks_reachable);
 419 extern SizeT MC_(blocks_suppressed);
 420
 421 typedef
 422    enum {
 423       LC_Off,
 424       LC_Summary,
 425       LC_Full,
 426    }
 427    LeakCheckMode;
 428
 429 typedef
 430    enum {
 431       LCD_Any,       // output all loss records, whatever the delta
 432       LCD_Increased, // output loss records with an increase in size or blocks
 433       LCD_Changed,   // output loss records with an increase or
 434                      //decrease in size or blocks
 435    }
 436    LeakCheckDeltaMode;
 437
 438 /* When a LossRecord is put into an OSet, these elements represent the key. */
 439 typedef
 440    struct _LossRecordKey {
 441       Reachedness  state;        // LC_Extra.state value shared by all blocks.
 442       ExeContext*  allocated_at; // Where they were allocated.
 443    }
 444    LossRecordKey;
 445
 446 /* A loss record, used for generating err msgs.  Multiple leaked blocks can be
 447  * merged into a single loss record if they have the same state and similar
 448  * enough allocation points (controlled by --leak-resolution). */
 449 typedef
 450    struct _LossRecord {
 451       LossRecordKey key;  // Key, when used in an OSet.
 452       SizeT szB;          // Sum of all MC_Chunk.szB values.
 453       SizeT indirect_szB; // Sum of all LC_Extra.indirect_szB values.
 454       UInt  num_blocks;   // Number of blocks represented by the record.
 455       SizeT old_szB;          // old_* values are the values found during the
 456       SizeT old_indirect_szB; // previous leak search. old_* values are used to
 457       UInt  old_num_blocks;   // output only the changed/new loss records
 458    }
 459    LossRecord;
 460
 461 typedef
 462    struct _LeakCheckParams {
 463       LeakCheckMode mode;
 464       UInt show_leak_kinds;
 465       UInt errors_for_leak_kinds;
 466       UInt heuristics;
 467       LeakCheckDeltaMode deltamode;
 468       UInt max_loss_records_output; // limit on the nr of loss records output.
 469       Bool requested_by_monitor_command; // True when requested by gdb/vgdb.
 470       const HChar* xt_filename; // if != NULL, produce an xtree leak file.
 471    }
 472    LeakCheckParams;
 473
 474 void MC_(detect_memory_leaks) ( ThreadId tid, LeakCheckParams * lcp);
 475
 476 // Each time a leak search is done, the leak search generation
 477 // MC_(leak_search_gen) is incremented.
 478 extern UInt MC_(leak_search_gen);
 479
 480 // maintains the lcp.deltamode given in the last call to detect_memory_leaks
 481 extern LeakCheckDeltaMode MC_(detect_memory_leaks_last_delta_mode);
 482
 483 // prints the list of blocks corresponding to the given loss_record_nr slice
 484 // (from/to) (up to maximum max_blocks)
 485 // Returns True if loss_record_nr_from identifies a correct loss record
 486 // from last leak search, returns False otherwise.
 487 // Note that loss_record_nr_to can be bigger than the nr of loss records. All
 488 // loss records after from will then be examined and maybe printed.
 489 // If heuristics != 0, print only the loss records/blocks found via
 490 // one of the heuristics in the set.
 491 Bool MC_(print_block_list) ( UInt loss_record_nr_from, UInt loss_record_nr_to,
 492                              UInt max_blocks, UInt heuristics);
 493
 494 // Prints the addresses/registers/... at which a pointer to
 495 // the given range [address, address+szB[ is found.
 496 void MC_(who_points_at) ( Addr address, SizeT szB);
 497
 498 // if delta_mode == LCD_Any, prints in buf an empty string
 499 // otherwise prints a delta in the layout  " (+%'lu)" or " (-%'lu)"
 500 extern HChar * MC_(snprintf_delta) (HChar * buf, Int size,
 501                                     SizeT current_val, SizeT old_val,
 502                                     LeakCheckDeltaMode delta_mode);
 503
 504
 505 Bool MC_(is_valid_aligned_word)     ( Addr a );
 506 Bool MC_(is_within_valid_secondary) ( Addr a );
 507
 508 // Prints as user msg a description of the given loss record.
 509 void MC_(pp_LossRecord)(UInt n_this_record, UInt n_total_records,
 510                         LossRecord* l);
 511
 512
 513 /*------------------------------------------------------------*/
 514 /*--- Errors and suppressions                              ---*/
 515 /*------------------------------------------------------------*/
 516
 517 /* Did we show to the user, any errors for which an uninitialised
 518    value origin could have been collected (but wasn't) ?  If yes,
 519    then, at the end of the run, print a 1 line message advising that a
 520    rerun with --track-origins=yes might help. */
 521 extern Bool MC_(any_value_errors);
 522
 523 /* Standard functions for error and suppressions as required by the
 524    core/tool iface */
 525 Bool MC_(eq_Error)           ( VgRes res, const Error* e1, const Error* e2 );
 526 void MC_(before_pp_Error)    ( const Error* err );
 527 void MC_(pp_Error)           ( const Error* err );
 528 UInt MC_(update_Error_extra) ( const Error* err );
 529
 530 Bool MC_(is_recognised_suppression) ( const HChar* name, Supp* su );
 531
 532 Bool MC_(read_extra_suppression_info) ( Int fd, HChar** buf,
 533                                         SizeT* nBuf, Int* lineno, Supp *su );
 534
 535 Bool MC_(error_matches_suppression) ( const Error* err, const Supp* su );
 536
 537 SizeT MC_(get_extra_suppression_info) ( const Error* err,
 538                                         /*OUT*/HChar* buf, Int nBuf );
 539 SizeT MC_(print_extra_suppression_use) ( const Supp* su,
 540                                          /*OUT*/HChar* buf, Int nBuf );
 541 void MC_(update_extra_suppression_use) ( const Error* err, const Supp* su );
 542
 543 const HChar* MC_(get_error_name) ( const Error* err );
 544
 545 /* Recording of errors */
 546 void MC_(record_address_error) ( ThreadId tid, Addr a, Int szB,
 547                                  Bool isWrite );
 548 void MC_(record_cond_error)    ( ThreadId tid, UInt otag );
 549 void MC_(record_value_error)   ( ThreadId tid, Int szB, UInt otag );
 550 void MC_(record_jump_error)    ( ThreadId tid, Addr a );
 551
 552 void MC_(record_free_error)            ( ThreadId tid, Addr a );
 553 void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a );
 554 void MC_(record_freemismatch_error)    ( ThreadId tid, MC_Chunk* mc );
 555
 556 void MC_(record_overlap_error)  ( ThreadId tid, const HChar* function,
 557                                   Addr src, Addr dst, SizeT szB );
 558 void MC_(record_core_mem_error) ( ThreadId tid, const HChar* msg );
 559 void MC_(record_regparam_error) ( ThreadId tid, const HChar* msg, UInt otag );
 560 void MC_(record_memparam_error) ( ThreadId tid, Addr a,
 561                                   Bool isAddrErr, const HChar* msg, UInt otag );
 562 void MC_(record_user_error)     ( ThreadId tid, Addr a,
 563                                   Bool isAddrErr, UInt otag );
 564
 565 Bool MC_(record_leak_error)     ( ThreadId tid,
 566                                   UInt n_this_record,
 567                                   UInt n_total_records,
 568                                   LossRecord* lossRecord,
 569                                   Bool print_record,
 570                                   Bool count_error );
 571
 572 Bool MC_(record_fishy_value_error)  ( ThreadId tid, const HChar* function,
 573                                       const HChar *argument_name, SizeT value );
 574
 575 /* Leak kinds tokens to call VG_(parse_enum_set). */
 576 extern const HChar* MC_(parse_leak_kinds_tokens);
 577
 578 /* prints a description of address a in the specified debuginfo epoch */
 579 void MC_(pp_describe_addr) ( DiEpoch ep, Addr a );
 580
 581 /* Is this address in a user-specified "ignored range" ? */
 582 Bool MC_(in_ignored_range) ( Addr a );
 583
 584 /* Is this address in a user-specified "ignored range of offsets below
 585    the current thread's stack pointer?" */
 586 Bool MC_(in_ignored_range_below_sp) ( Addr sp, Addr a, UInt szB );
 587
 588
 589 /*------------------------------------------------------------*/
 590 /*--- Client blocks                                        ---*/
 591 /*------------------------------------------------------------*/
 592
 593 /* Describes a client block.  See mc_main.c.  An unused block has
 594    start == size == 0.  */
 595 typedef
 596    struct {
 597       Addr        start;
 598       SizeT       size;
 599       ExeContext* where;
 600       HChar*      desc;
 601    }
 602    CGenBlock;
 603
 604 /* Get access to the client block array. */
 605 void MC_(get_ClientBlock_array)( /*OUT*/CGenBlock** blocks,
 606                                  /*OUT*/UWord* nBlocks );
 607
 608
 609 /*------------------------------------------------------------*/
 610 /*--- Command line options + defaults                      ---*/
 611 /*------------------------------------------------------------*/
 612
 613 /* Allow loads from partially-valid addresses?  default: YES */
 614 extern Bool MC_(clo_partial_loads_ok);
 615
 616 /* Max volume of the freed blocks queue. */
 617 extern Long MC_(clo_freelist_vol);
 618
 619 /* Blocks with a size >= MC_(clo_freelist_big_blocks) will be put
 620    in the "big block" freed blocks queue. */
 621 extern Long MC_(clo_freelist_big_blocks);
 622
 623 /* Do leak check at exit?  default: NO */
 624 extern LeakCheckMode MC_(clo_leak_check);
 625
 626 /* How closely should we compare ExeContexts in leak records? default: 2 */
 627 extern VgRes MC_(clo_leak_resolution);
 628
 629 /* In leak check, show loss records if their R2S(reachedness) is set.
 630    Default : R2S(Possible) | R2S(Unreached). */
 631 extern UInt MC_(clo_show_leak_kinds);
 632
 633 /* In leak check, a loss record is an error if its R2S(reachedness) is set.
 634    Default : R2S(Possible) | R2S(Unreached). */
 635 extern UInt MC_(clo_errors_for_leak_kinds);
 636
 637 /* Various leak check heuristics which can be activated/deactivated. */
 638 typedef
 639    enum {
 640       LchNone                =0,
 641       // no heuristic.
 642       LchStdString           =1,
 643       // Consider interior pointer pointing at the array of char in a
 644       // std::string as reachable.
 645       LchLength64            =2,
 646       // Consider interior pointer pointing at offset 64bit of a block as
 647       // reachable, when the first 8 bytes contains the block size - 8.
 648       // Such length+interior pointers are used by e.g. sqlite3MemMalloc.
 649       // On 64bit platforms LchNewArray will also match these blocks.
 650       LchNewArray            =3,
 651       // Consider interior pointer pointing at second word of a new[] array as
 652       // reachable. Such interior pointers are used for arrays whose elements
 653       // have a destructor.
 654       LchMultipleInheritance =4,
 655       // Conside interior pointer pointing just after what looks a vtable
 656       // as reachable.
 657   }
 658   LeakCheckHeuristic;
 659
 660 // Nr of heuristics, including the LchNone heuristic.
 661 #define N_LEAK_CHECK_HEURISTICS 5
 662
 663 // Build mask to check or set Heuristic h membership
 664 #define H2S(h) (1 << (h))
 665 // Heuristic h is member of the Set s ?
 666 #define HiS(h,s) ((s) & H2S(h))
 667
 668 /* Heuristics set to use for the leak search.
 669    Default : all heuristics. */
 670 extern UInt MC_(clo_leak_check_heuristics);
 671
 672 /* Assume accesses immediately below %esp are due to gcc-2.96 bugs.
 673  * default: NO */
 674 extern Bool MC_(clo_workaround_gcc296_bugs);
 675
 676 /* Fill malloc-d/free-d client blocks with a specific value?  -1 if
 677    not, else 0x00 .. 0xFF indicating the fill value to use.  Can be
 678    useful for causing programs with bad heap corruption to fail in
 679    more repeatable ways.  Note that malloc-filled and free-filled
 680    areas are still undefined and noaccess respectively.  This merely
 681    causes them to contain the specified values. */
 682 extern Int MC_(clo_malloc_fill);
 683 extern Int MC_(clo_free_fill);
 684
 685 /* Which stack trace(s) to keep for malloc'd/free'd client blocks?
 686    For each client block, the stack traces where it was allocated
 687    and/or freed are optionally kept depending on MC_(clo_keep_stacktraces). */
 688 typedef
 689    enum {                 // keep alloc stack trace ?  keep free stack trace ?
 690       KS_none,            // never                     never
 691       KS_alloc,           // always                    never
 692       KS_free,            // never                     always
 693       KS_alloc_then_free, // when still malloc'd       when free'd
 694       KS_alloc_and_free,  // always                    always
 695    }
 696    KeepStacktraces;
 697 extern KeepStacktraces MC_(clo_keep_stacktraces);
 698
 699 /* Indicates the level of instrumentation/checking done by Memcheck.
 700
 701    1 = No undefined value checking, Addrcheck-style behaviour only:
 702        only address checking is done.  This is faster but finds fewer
 703        errors.  Note that although Addrcheck had 1 bit per byte
 704        overhead vs the old Memcheck's 9 bits per byte, with this mode
 705        and compressed V bits, no memory is saved with this mode --
 706        it's still 2 bits per byte overhead.  This is a little wasteful
 707        -- it could be done with 1 bit per byte -- but lets us reuse
 708        the many shadow memory access functions.  Note that in this
 709        mode neither the secondary V bit table nor the origin-tag cache
 710        are used.
 711
 712    2 = Address checking and Undefined value checking are performed,
 713        but origins are not tracked.  So the origin-tag cache is not
 714        used in this mode.  This setting is the default and corresponds
 715        to the "normal" Memcheck behaviour that has shipped for years.
 716
 717    3 = Address checking, undefined value checking, and origins for
 718        undefined values are tracked.
 719
 720    The default is 2.
 721 */
 722 extern Int MC_(clo_mc_level);
 723
 724 /* Should we show mismatched frees?  Default: YES */
 725 extern Bool MC_(clo_show_mismatched_frees);
 726
 727 /* Indicates the level of detail for Vbit tracking through integer add,
 728    subtract, and some integer comparison operations. */
 729 typedef
 730    enum {
 731       EdcNO = 1000,  // All operations instrumented cheaply
 732       EdcAUTO,       // Chosen dynamically by analysing the block
 733       EdcYES         // All operations instrumented expensively
 734    }
 735    ExpensiveDefinednessChecks;
 736
 737 /* Level of expense in definedness checking for add/sub and compare
 738    operations.  Default: EdcAUTO */
 739 extern ExpensiveDefinednessChecks MC_(clo_expensive_definedness_checks);
 740
 741 /* Do we have a range of stack offsets to ignore?  Default: NO */
 742 extern Bool MC_(clo_ignore_range_below_sp);
 743 extern UInt MC_(clo_ignore_range_below_sp__first_offset);
 744 extern UInt MC_(clo_ignore_range_below_sp__last_offset);
 745
 746
 747 /*------------------------------------------------------------*/
 748 /*--- Instrumentation                                      ---*/
 749 /*------------------------------------------------------------*/
 750
 751 /* Functions defined in mc_main.c */
 752
 753 /* For the fail_w_o functions, the UWord arg is actually the 32-bit
 754    origin tag and should really be UInt, but to be simple and safe
 755    considering it's called from generated code, just claim it to be a
 756    UWord. */
 757 VG_REGPARM(2) void MC_(helperc_value_checkN_fail_w_o) ( HWord, UWord );
 758 VG_REGPARM(1) void MC_(helperc_value_check8_fail_w_o) ( UWord );
 759 VG_REGPARM(1) void MC_(helperc_value_check4_fail_w_o) ( UWord );
 760 VG_REGPARM(1) void MC_(helperc_value_check1_fail_w_o) ( UWord );
 761 VG_REGPARM(1) void MC_(helperc_value_check0_fail_w_o) ( UWord );
 762
 763 /* And call these ones instead to report an uninitialised value error
 764    but with no origin available. */
 765 VG_REGPARM(1) void MC_(helperc_value_checkN_fail_no_o) ( HWord );
 766 VG_REGPARM(0) void MC_(helperc_value_check8_fail_no_o) ( void );
 767 VG_REGPARM(0) void MC_(helperc_value_check4_fail_no_o) ( void );
 768 VG_REGPARM(0) void MC_(helperc_value_check1_fail_no_o) ( void );
 769 VG_REGPARM(0) void MC_(helperc_value_check0_fail_no_o) ( void );
 770
 771 /* V-bits load/store helpers */
 772 VG_REGPARM(1) void MC_(helperc_STOREV64be) ( Addr, ULong );
 773 VG_REGPARM(1) void MC_(helperc_STOREV64le) ( Addr, ULong );
 774 VG_REGPARM(2) void MC_(helperc_STOREV32be) ( Addr, UWord );
 775 VG_REGPARM(2) void MC_(helperc_STOREV32le) ( Addr, UWord );
 776 VG_REGPARM(2) void MC_(helperc_STOREV16be) ( Addr, UWord );
 777 VG_REGPARM(2) void MC_(helperc_STOREV16le) ( Addr, UWord );
 778 VG_REGPARM(2) void MC_(helperc_STOREV8)    ( Addr, UWord );
 779
 780 VG_REGPARM(2) void  MC_(helperc_LOADV256be) ( /*OUT*/V256*, Addr );
 781 VG_REGPARM(2) void  MC_(helperc_LOADV256le) ( /*OUT*/V256*, Addr );
 782 VG_REGPARM(2) void  MC_(helperc_LOADV128be) ( /*OUT*/V128*, Addr );
 783 VG_REGPARM(2) void  MC_(helperc_LOADV128le) ( /*OUT*/V128*, Addr );
 784 VG_REGPARM(1) ULong MC_(helperc_LOADV64be)  ( Addr );
 785 VG_REGPARM(1) ULong MC_(helperc_LOADV64le)  ( Addr );
 786 VG_REGPARM(1) UWord MC_(helperc_LOADV32be)  ( Addr );
 787 VG_REGPARM(1) UWord MC_(helperc_LOADV32le)  ( Addr );
 788 VG_REGPARM(1) UWord MC_(helperc_LOADV16be)  ( Addr );
 789 VG_REGPARM(1) UWord MC_(helperc_LOADV16le)  ( Addr );
 790 VG_REGPARM(1) UWord MC_(helperc_LOADV8)     ( Addr );
 791
 792 VG_REGPARM(3)
 793 void MC_(helperc_MAKE_STACK_UNINIT_w_o) ( Addr base, UWord len, Addr nia );
 794
 795 VG_REGPARM(2)
 796 void MC_(helperc_MAKE_STACK_UNINIT_no_o) ( Addr base, UWord len );
 797
 798 VG_REGPARM(1)
 799 void MC_(helperc_MAKE_STACK_UNINIT_128_no_o) ( Addr base );
 800
 801 /* Origin tag load/store helpers */
 802 VG_REGPARM(2) void  MC_(helperc_b_store1) ( Addr a, UWord d32 );
 803 VG_REGPARM(2) void  MC_(helperc_b_store2) ( Addr a, UWord d32 );
 804 VG_REGPARM(2) void  MC_(helperc_b_store4) ( Addr a, UWord d32 );
 805 VG_REGPARM(2) void  MC_(helperc_b_store8) ( Addr a, UWord d32 );
 806 VG_REGPARM(2) void  MC_(helperc_b_store16)( Addr a, UWord d32 );
 807 VG_REGPARM(2) void  MC_(helperc_b_store32)( Addr a, UWord d32 );
 808 VG_REGPARM(1) UWord MC_(helperc_b_load1) ( Addr a );
 809 VG_REGPARM(1) UWord MC_(helperc_b_load2) ( Addr a );
 810 VG_REGPARM(1) UWord MC_(helperc_b_load4) ( Addr a );
 811 VG_REGPARM(1) UWord MC_(helperc_b_load8) ( Addr a );
 812 VG_REGPARM(1) UWord MC_(helperc_b_load16)( Addr a );
 813 VG_REGPARM(1) UWord MC_(helperc_b_load32)( Addr a );
 814
 815 /* Functions defined in mc_translate.c */
 816 IRSB* MC_(instrument) ( VgCallbackClosure* closure,
 817                         IRSB* bb_in,
 818                         const VexGuestLayout* layout,
 819                         const VexGuestExtents* vge,
 820                         const VexArchInfo* archinfo_host,
 821                         IRType gWordTy, IRType hWordTy );
 822
 823 IRSB* MC_(final_tidy) ( IRSB* );
 824
 825 /* Check some assertions to do with the instrumentation machinery. */
 826 void MC_(do_instrumentation_startup_checks)( void );
 827
 828 #endif /* ndef __MC_INCLUDE_H */
 829
 830 /*--------------------------------------------------------------------*/
 831 /*--- end                                                          ---*/
 832 /*--------------------------------------------------------------------*/