mc_include.h revision 362441db825242200142a91bb07c4a0300b36a3e
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-2012 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// A set with all Reachedness: 283#define RallS \ 284 (R2S(Reachable) | R2S(Possible) | R2S(IndirectLeak) | R2S(Unreached)) 285 286/* For VALGRIND_COUNT_LEAKS client request */ 287extern SizeT MC_(bytes_leaked); 288extern SizeT MC_(bytes_indirect); 289extern SizeT MC_(bytes_dubious); 290extern SizeT MC_(bytes_reachable); 291extern SizeT MC_(bytes_suppressed); 292 293/* For VALGRIND_COUNT_LEAK_BLOCKS client request */ 294extern SizeT MC_(blocks_leaked); 295extern SizeT MC_(blocks_indirect); 296extern SizeT MC_(blocks_dubious); 297extern SizeT MC_(blocks_reachable); 298extern SizeT MC_(blocks_suppressed); 299 300typedef 301 enum { 302 LC_Off, 303 LC_Summary, 304 LC_Full, 305 } 306 LeakCheckMode; 307 308typedef 309 enum { 310 LCD_Any, // output all loss records, whatever the delta 311 LCD_Increased, // output loss records with an increase in size or blocks 312 LCD_Changed, // output loss records with an increase or 313 //decrease in size or blocks 314 } 315 LeakCheckDeltaMode; 316 317/* When a LossRecord is put into an OSet, these elements represent the key. */ 318typedef 319 struct _LossRecordKey { 320 Reachedness state; // LC_Extra.state value shared by all blocks. 321 ExeContext* allocated_at; // Where they were allocated. 322 } 323 LossRecordKey; 324 325/* A loss record, used for generating err msgs. Multiple leaked blocks can be 326 * merged into a single loss record if they have the same state and similar 327 * enough allocation points (controlled by --leak-resolution). */ 328typedef 329 struct _LossRecord { 330 LossRecordKey key; // Key, when used in an OSet. 331 SizeT szB; // Sum of all MC_Chunk.szB values. 332 SizeT indirect_szB; // Sum of all LC_Extra.indirect_szB values. 333 UInt num_blocks; // Number of blocks represented by the record. 334 SizeT old_szB; // old_* values are the values found during the 335 SizeT old_indirect_szB; // previous leak search. old_* values are used to 336 UInt old_num_blocks; // output only the changed/new loss records 337 } 338 LossRecord; 339 340typedef 341 struct _LeakCheckParams { 342 LeakCheckMode mode; 343 UInt show_leak_kinds; 344 UInt errors_for_leak_kinds; 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// maintains the lcp.deltamode given in the last call to detect_memory_leaks 354extern LeakCheckDeltaMode MC_(detect_memory_leaks_last_delta_mode); 355 356// prints the list of blocks corresponding to the given loss_record_nr. 357// Returns True if loss_record_nr identifies a correct loss record from last leak search. 358// Returns False otherwise. 359Bool MC_(print_block_list) ( UInt loss_record_nr); 360 361// Prints the addresses/registers/... at which a pointer to 362// the given range [address, address+szB[ is found. 363void MC_(who_points_at) ( Addr address, SizeT szB); 364 365// if delta_mode == LCD_Any, prints in buf an empty string 366// otherwise prints a delta in the layout " (+%'lu)" or " (-%'lu)" 367extern HChar * MC_(snprintf_delta) (HChar * buf, Int size, 368 SizeT current_val, SizeT old_val, 369 LeakCheckDeltaMode delta_mode); 370 371 372Bool MC_(is_valid_aligned_word) ( Addr a ); 373Bool MC_(is_within_valid_secondary) ( Addr a ); 374 375// Prints as user msg a description of the given loss record. 376void MC_(pp_LossRecord)(UInt n_this_record, UInt n_total_records, 377 LossRecord* l); 378 379 380/*------------------------------------------------------------*/ 381/*--- Errors and suppressions ---*/ 382/*------------------------------------------------------------*/ 383 384/* Did we show to the user, any errors for which an uninitialised 385 value origin could have been collected (but wasn't) ? If yes, 386 then, at the end of the run, print a 1 line message advising that a 387 rerun with --track-origins=yes might help. */ 388extern Bool MC_(any_value_errors); 389 390/* Standard functions for error and suppressions as required by the 391 core/tool iface */ 392Bool MC_(eq_Error) ( VgRes res, Error* e1, Error* e2 ); 393void MC_(before_pp_Error) ( Error* err ); 394void MC_(pp_Error) ( Error* err ); 395UInt MC_(update_Error_extra) ( Error* err ); 396 397Bool MC_(is_recognised_suppression) ( const HChar* name, Supp* su ); 398 399Bool MC_(read_extra_suppression_info) ( Int fd, HChar** buf, 400 SizeT* nBuf, Int* lineno, Supp *su ); 401 402Bool MC_(error_matches_suppression) ( Error* err, Supp* su ); 403 404Bool MC_(get_extra_suppression_info) ( Error* err, 405 /*OUT*/HChar* buf, Int nBuf ); 406 407const HChar* MC_(get_error_name) ( Error* err ); 408 409/* Recording of errors */ 410void MC_(record_address_error) ( ThreadId tid, Addr a, Int szB, 411 Bool isWrite ); 412void MC_(record_cond_error) ( ThreadId tid, UInt otag ); 413void MC_(record_value_error) ( ThreadId tid, Int szB, UInt otag ); 414void MC_(record_jump_error) ( ThreadId tid, Addr a ); 415 416void MC_(record_free_error) ( ThreadId tid, Addr a ); 417void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a ); 418void MC_(record_freemismatch_error) ( ThreadId tid, MC_Chunk* mc ); 419 420void MC_(record_overlap_error) ( ThreadId tid, const HChar* function, 421 Addr src, Addr dst, SizeT szB ); 422void MC_(record_core_mem_error) ( ThreadId tid, const HChar* msg ); 423void MC_(record_regparam_error) ( ThreadId tid, const HChar* msg, UInt otag ); 424void MC_(record_memparam_error) ( ThreadId tid, Addr a, 425 Bool isAddrErr, const HChar* msg, UInt otag ); 426void MC_(record_user_error) ( ThreadId tid, Addr a, 427 Bool isAddrErr, UInt otag ); 428 429Bool MC_(record_leak_error) ( ThreadId tid, 430 UInt n_this_record, 431 UInt n_total_records, 432 LossRecord* lossRecord, 433 Bool print_record, 434 Bool count_error ); 435 436/* Parses a set of leak kinds (separated by ,). 437 and give the resulting set in *lks. 438 If parsing is succesful, returns True and *lks contains the resulting set. 439 else return False. */ 440extern Bool MC_(parse_leak_kinds) ( const HChar* str0, UInt* lks ); 441 442/* prints a description of address a */ 443void MC_(pp_describe_addr) (Addr a); 444 445/* Is this address in a user-specified "ignored range" ? */ 446Bool MC_(in_ignored_range) ( Addr a ); 447 448 449/*------------------------------------------------------------*/ 450/*--- Client blocks ---*/ 451/*------------------------------------------------------------*/ 452 453/* Describes a client block. See mc_main.c. An unused block has 454 start == size == 0. */ 455typedef 456 struct { 457 Addr start; 458 SizeT size; 459 ExeContext* where; 460 HChar* desc; 461 } 462 CGenBlock; 463 464/* Get access to the client block array. */ 465void MC_(get_ClientBlock_array)( /*OUT*/CGenBlock** blocks, 466 /*OUT*/UWord* nBlocks ); 467 468 469/*------------------------------------------------------------*/ 470/*--- Command line options + defaults ---*/ 471/*------------------------------------------------------------*/ 472 473/* Allow loads from partially-valid addresses? default: YES */ 474extern Bool MC_(clo_partial_loads_ok); 475 476/* Max volume of the freed blocks queue. */ 477extern Long MC_(clo_freelist_vol); 478 479/* Blocks with a size >= MC_(clo_freelist_big_blocks) will be put 480 in the "big block" freed blocks queue. */ 481extern Long MC_(clo_freelist_big_blocks); 482 483/* Do leak check at exit? default: NO */ 484extern LeakCheckMode MC_(clo_leak_check); 485 486/* How closely should we compare ExeContexts in leak records? default: 2 */ 487extern VgRes MC_(clo_leak_resolution); 488 489/* In leak check, show loss records if their R2S(reachedness) is set. 490 Default : R2S(Possible) | R2S(Unreached). */ 491extern UInt MC_(clo_show_leak_kinds); 492 493/* In leak check, a loss record is an error if its R2S(reachedness) is set. 494 Default : R2S(Possible) | R2S(Unreached). */ 495extern UInt MC_(clo_errors_for_leak_kinds); 496 497/* Assume accesses immediately below %esp are due to gcc-2.96 bugs. 498 * default: NO */ 499extern Bool MC_(clo_workaround_gcc296_bugs); 500 501/* Fill malloc-d/free-d client blocks with a specific value? -1 if 502 not, else 0x00 .. 0xFF indicating the fill value to use. Can be 503 useful for causing programs with bad heap corruption to fail in 504 more repeatable ways. Note that malloc-filled and free-filled 505 areas are still undefined and noaccess respectively. This merely 506 causes them to contain the specified values. */ 507extern Int MC_(clo_malloc_fill); 508extern Int MC_(clo_free_fill); 509 510/* Which stack trace(s) to keep for malloc'd/free'd client blocks? 511 For each client block, the stack traces where it was allocated 512 and/or freed are optionally kept depending on MC_(clo_keep_stacktraces). */ 513typedef 514 enum { // keep alloc stack trace ? keep free stack trace ? 515 KS_none, // never never 516 KS_alloc, // always never 517 KS_free, // never always 518 KS_alloc_then_free, // when still malloc'd when free'd 519 KS_alloc_and_free, // always always 520 } 521 KeepStacktraces; 522extern KeepStacktraces MC_(clo_keep_stacktraces); 523 524/* Indicates the level of instrumentation/checking done by Memcheck. 525 526 1 = No undefined value checking, Addrcheck-style behaviour only: 527 only address checking is done. This is faster but finds fewer 528 errors. Note that although Addrcheck had 1 bit per byte 529 overhead vs the old Memcheck's 9 bits per byte, with this mode 530 and compressed V bits, no memory is saved with this mode -- 531 it's still 2 bits per byte overhead. This is a little wasteful 532 -- it could be done with 1 bit per byte -- but lets us reuse 533 the many shadow memory access functions. Note that in this 534 mode neither the secondary V bit table nor the origin-tag cache 535 are used. 536 537 2 = Address checking and Undefined value checking are performed, 538 but origins are not tracked. So the origin-tag cache is not 539 used in this mode. This setting is the default and corresponds 540 to the "normal" Memcheck behaviour that has shipped for years. 541 542 3 = Address checking, undefined value checking, and origins for 543 undefined values are tracked. 544 545 The default is 2. 546*/ 547extern Int MC_(clo_mc_level); 548 549 550/*------------------------------------------------------------*/ 551/*--- Instrumentation ---*/ 552/*------------------------------------------------------------*/ 553 554/* Functions defined in mc_main.c */ 555 556/* For the fail_w_o functions, the UWord arg is actually the 32-bit 557 origin tag and should really be UInt, but to be simple and safe 558 considering it's called from generated code, just claim it to be a 559 UWord. */ 560VG_REGPARM(2) void MC_(helperc_value_checkN_fail_w_o) ( HWord, UWord ); 561VG_REGPARM(1) void MC_(helperc_value_check8_fail_w_o) ( UWord ); 562VG_REGPARM(1) void MC_(helperc_value_check4_fail_w_o) ( UWord ); 563VG_REGPARM(1) void MC_(helperc_value_check1_fail_w_o) ( UWord ); 564VG_REGPARM(1) void MC_(helperc_value_check0_fail_w_o) ( UWord ); 565 566/* And call these ones instead to report an uninitialised value error 567 but with no origin available. */ 568VG_REGPARM(1) void MC_(helperc_value_checkN_fail_no_o) ( HWord ); 569VG_REGPARM(0) void MC_(helperc_value_check8_fail_no_o) ( void ); 570VG_REGPARM(0) void MC_(helperc_value_check4_fail_no_o) ( void ); 571VG_REGPARM(0) void MC_(helperc_value_check1_fail_no_o) ( void ); 572VG_REGPARM(0) void MC_(helperc_value_check0_fail_no_o) ( void ); 573 574/* V-bits load/store helpers */ 575VG_REGPARM(1) void MC_(helperc_STOREV64be) ( Addr, ULong ); 576VG_REGPARM(1) void MC_(helperc_STOREV64le) ( Addr, ULong ); 577VG_REGPARM(2) void MC_(helperc_STOREV32be) ( Addr, UWord ); 578VG_REGPARM(2) void MC_(helperc_STOREV32le) ( Addr, UWord ); 579VG_REGPARM(2) void MC_(helperc_STOREV16be) ( Addr, UWord ); 580VG_REGPARM(2) void MC_(helperc_STOREV16le) ( Addr, UWord ); 581VG_REGPARM(2) void MC_(helperc_STOREV8) ( Addr, UWord ); 582 583VG_REGPARM(1) ULong MC_(helperc_LOADV64be) ( Addr ); 584VG_REGPARM(1) ULong MC_(helperc_LOADV64le) ( Addr ); 585VG_REGPARM(1) UWord MC_(helperc_LOADV32be) ( Addr ); 586VG_REGPARM(1) UWord MC_(helperc_LOADV32le) ( Addr ); 587VG_REGPARM(1) UWord MC_(helperc_LOADV16be) ( Addr ); 588VG_REGPARM(1) UWord MC_(helperc_LOADV16le) ( Addr ); 589VG_REGPARM(1) UWord MC_(helperc_LOADV8) ( Addr ); 590 591void MC_(helperc_MAKE_STACK_UNINIT) ( Addr base, UWord len, 592 Addr nia ); 593 594/* Origin tag load/store helpers */ 595VG_REGPARM(2) void MC_(helperc_b_store1) ( Addr a, UWord d32 ); 596VG_REGPARM(2) void MC_(helperc_b_store2) ( Addr a, UWord d32 ); 597VG_REGPARM(2) void MC_(helperc_b_store4) ( Addr a, UWord d32 ); 598VG_REGPARM(2) void MC_(helperc_b_store8) ( Addr a, UWord d32 ); 599VG_REGPARM(2) void MC_(helperc_b_store16)( Addr a, UWord d32 ); 600VG_REGPARM(2) void MC_(helperc_b_store32)( Addr a, UWord d32 ); 601VG_REGPARM(1) UWord MC_(helperc_b_load1) ( Addr a ); 602VG_REGPARM(1) UWord MC_(helperc_b_load2) ( Addr a ); 603VG_REGPARM(1) UWord MC_(helperc_b_load4) ( Addr a ); 604VG_REGPARM(1) UWord MC_(helperc_b_load8) ( Addr a ); 605VG_REGPARM(1) UWord MC_(helperc_b_load16)( Addr a ); 606VG_REGPARM(1) UWord MC_(helperc_b_load32)( Addr a ); 607 608/* Functions defined in mc_translate.c */ 609IRSB* MC_(instrument) ( VgCallbackClosure* closure, 610 IRSB* bb_in, 611 VexGuestLayout* layout, 612 VexGuestExtents* vge, 613 VexArchInfo* archinfo_host, 614 IRType gWordTy, IRType hWordTy ); 615 616IRSB* MC_(final_tidy) ( IRSB* ); 617 618#endif /* ndef __MC_INCLUDE_H */ 619 620/*--------------------------------------------------------------------*/ 621/*--- end ---*/ 622/*--------------------------------------------------------------------*/ 623