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