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