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 (at) 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 /*--------------------------------------------------------------------*/ 672
