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; // Where it was allocated. 71 } 72 MC_Chunk; 73 74/* Memory pool. Nb: first two fields must match core's VgHashNode. */ 75typedef 76 struct _MC_Mempool { 77 struct _MC_Mempool* next; 78 Addr pool; // pool identifier 79 SizeT rzB; // pool red-zone size 80 Bool is_zeroed; // allocations from this pool are zeroed 81 VgHashTable chunks; // chunks associated with this pool 82 } 83 MC_Mempool; 84 85 86void* MC_(new_block) ( ThreadId tid, 87 Addr p, SizeT size, SizeT align, 88 Bool is_zeroed, MC_AllocKind kind, 89 VgHashTable table); 90void MC_(handle_free) ( ThreadId tid, 91 Addr p, UInt rzB, MC_AllocKind kind ); 92 93void MC_(create_mempool) ( Addr pool, UInt rzB, Bool is_zeroed ); 94void MC_(destroy_mempool) ( Addr pool ); 95void MC_(mempool_alloc) ( ThreadId tid, Addr pool, 96 Addr addr, SizeT size ); 97void MC_(mempool_free) ( Addr pool, Addr addr ); 98void MC_(mempool_trim) ( Addr pool, Addr addr, SizeT size ); 99void MC_(move_mempool) ( Addr poolA, Addr poolB ); 100void MC_(mempool_change) ( Addr pool, Addr addrA, Addr addrB, SizeT size ); 101Bool MC_(mempool_exists) ( Addr pool ); 102 103/* Searches for a recently freed block which might bracket Addr a. 104 Return the MC_Chunk* for this block or NULL if no bracketting block 105 is found. */ 106MC_Chunk* MC_(get_freed_block_bracketting)( Addr a ); 107 108/* For efficient pooled alloc/free of the MC_Chunk. */ 109extern PoolAlloc* MC_(chunk_poolalloc); 110 111/* For tracking malloc'd blocks. Nb: it's quite important that it's a 112 VgHashTable, because VgHashTable allows duplicate keys without complaint. 113 This can occur if a user marks a malloc() block as also a custom block with 114 MALLOCLIKE_BLOCK. */ 115extern VgHashTable MC_(malloc_list); 116 117/* For tracking memory pools. */ 118extern VgHashTable MC_(mempool_list); 119 120/* Shadow memory functions */ 121Bool MC_(check_mem_is_noaccess)( Addr a, SizeT len, Addr* bad_addr ); 122void MC_(make_mem_noaccess) ( Addr a, SizeT len ); 123void MC_(make_mem_undefined_w_otag)( Addr a, SizeT len, UInt otag ); 124void MC_(make_mem_defined) ( Addr a, SizeT len ); 125void MC_(copy_address_range_state) ( Addr src, Addr dst, SizeT len ); 126 127void MC_(print_malloc_stats) ( void ); 128/* nr of free operations done */ 129SizeT MC_(get_cmalloc_n_frees) ( void ); 130 131void* MC_(malloc) ( ThreadId tid, SizeT n ); 132void* MC_(__builtin_new) ( ThreadId tid, SizeT n ); 133void* MC_(__builtin_vec_new) ( ThreadId tid, SizeT n ); 134void* MC_(memalign) ( ThreadId tid, SizeT align, SizeT n ); 135void* MC_(calloc) ( ThreadId tid, SizeT nmemb, SizeT size1 ); 136void MC_(free) ( ThreadId tid, void* p ); 137void MC_(__builtin_delete) ( ThreadId tid, void* p ); 138void MC_(__builtin_vec_delete) ( ThreadId tid, void* p ); 139void* MC_(realloc) ( ThreadId tid, void* p, SizeT new_size ); 140SizeT MC_(malloc_usable_size) ( ThreadId tid, void* p ); 141 142void MC_(handle_resizeInPlace)(ThreadId tid, Addr p, 143 SizeT oldSizeB, SizeT newSizeB, SizeT rzB); 144 145 146/*------------------------------------------------------------*/ 147/*--- Origin tracking translate-time support ---*/ 148/*------------------------------------------------------------*/ 149 150/* See detailed comments in mc_machine.c. */ 151Int MC_(get_otrack_shadow_offset) ( Int offset, Int szB ); 152IRType MC_(get_otrack_reg_array_equiv_int_type) ( IRRegArray* arr ); 153 154/* Constants which are used as the lowest 2 bits in origin tags. 155 156 An origin tag comprises an upper 30-bit ECU field and a lower 2-bit 157 'kind' field. The ECU field is a number given out by m_execontext 158 and has a 1-1 mapping with ExeContext*s. An ECU can be used 159 directly as an origin tag (otag), but in fact we want to put 160 additional information 'kind' field to indicate roughly where the 161 tag came from. This helps print more understandable error messages 162 for the user -- it has no other purpose. 163 164 Hence the following 2-bit constants are needed for 'kind' field. 165 166 To summarise: 167 168 * Both ECUs and origin tags are represented as 32-bit words 169 170 * m_execontext and the core-tool interface deal purely in ECUs. 171 They have no knowledge of origin tags - that is a purely 172 Memcheck-internal matter. 173 174 * all valid ECUs have the lowest 2 bits zero and at least 175 one of the upper 30 bits nonzero (see VG_(is_plausible_ECU)) 176 177 * to convert from an ECU to an otag, OR in one of the MC_OKIND_ 178 constants below 179 180 * to convert an otag back to an ECU, AND it with ~3 181*/ 182 183#define MC_OKIND_UNKNOWN 0 /* unknown origin */ 184#define MC_OKIND_HEAP 1 /* this is a heap origin */ 185#define MC_OKIND_STACK 2 /* this is a stack origin */ 186#define MC_OKIND_USER 3 /* arises from user-supplied client req */ 187 188 189/*------------------------------------------------------------*/ 190/*--- Profiling of memory events ---*/ 191/*------------------------------------------------------------*/ 192 193/* Define to collect detailed performance info. */ 194/* #define MC_PROFILE_MEMORY */ 195 196#ifdef MC_PROFILE_MEMORY 197# define N_PROF_EVENTS 500 198 199UInt MC_(event_ctr)[N_PROF_EVENTS]; 200HChar* MC_(event_ctr_name)[N_PROF_EVENTS]; 201 202# define PROF_EVENT(ev, name) \ 203 do { tl_assert((ev) >= 0 && (ev) < N_PROF_EVENTS); \ 204 /* crude and inaccurate check to ensure the same */ \ 205 /* event isn't being used with > 1 name */ \ 206 if (MC_(event_ctr_name)[ev]) \ 207 tl_assert(name == MC_(event_ctr_name)[ev]); \ 208 MC_(event_ctr)[ev]++; \ 209 MC_(event_ctr_name)[ev] = (name); \ 210 } while (False); 211 212#else 213 214# define PROF_EVENT(ev, name) /* */ 215 216#endif /* MC_PROFILE_MEMORY */ 217 218 219/*------------------------------------------------------------*/ 220/*--- V and A bits (Victoria & Albert ?) ---*/ 221/*------------------------------------------------------------*/ 222 223/* The number of entries in the primary map can be altered. However 224 we hardwire the assumption that each secondary map covers precisely 225 64k of address space. */ 226#define SM_SIZE 65536 /* DO NOT CHANGE */ 227#define SM_MASK (SM_SIZE-1) /* DO NOT CHANGE */ 228 229#define V_BIT_DEFINED 0 230#define V_BIT_UNDEFINED 1 231 232#define V_BITS8_DEFINED 0 233#define V_BITS8_UNDEFINED 0xFF 234 235#define V_BITS16_DEFINED 0 236#define V_BITS16_UNDEFINED 0xFFFF 237 238#define V_BITS32_DEFINED 0 239#define V_BITS32_UNDEFINED 0xFFFFFFFF 240 241#define V_BITS64_DEFINED 0ULL 242#define V_BITS64_UNDEFINED 0xFFFFFFFFFFFFFFFFULL 243 244 245/*------------------------------------------------------------*/ 246/*--- Leak checking ---*/ 247/*------------------------------------------------------------*/ 248 249typedef 250 enum { 251 // Nb: the order is important -- it dictates the order of loss records 252 // of equal sizes. 253 Reachable =0, // Definitely reachable from root-set. 254 Possible =1, // Possibly reachable from root-set; involves at 255 // least one interior-pointer along the way. 256 IndirectLeak =2, // Leaked, but reachable from another leaked block 257 // (be it Unreached or IndirectLeak). 258 Unreached =3, // Not reached, ie. leaked. 259 // (At best, only reachable from itself via a cycle.) 260 } 261 Reachedness; 262 263 264/* For VALGRIND_COUNT_LEAKS client request */ 265extern SizeT MC_(bytes_leaked); 266extern SizeT MC_(bytes_indirect); 267extern SizeT MC_(bytes_dubious); 268extern SizeT MC_(bytes_reachable); 269extern SizeT MC_(bytes_suppressed); 270 271/* For VALGRIND_COUNT_LEAK_BLOCKS client request */ 272extern SizeT MC_(blocks_leaked); 273extern SizeT MC_(blocks_indirect); 274extern SizeT MC_(blocks_dubious); 275extern SizeT MC_(blocks_reachable); 276extern SizeT MC_(blocks_suppressed); 277 278typedef 279 enum { 280 LC_Off, 281 LC_Summary, 282 LC_Full, 283 } 284 LeakCheckMode; 285 286typedef 287 enum { 288 LCD_Any, // output all loss records, whatever the delta 289 LCD_Increased, // output loss records with an increase in size or blocks 290 LCD_Changed, // output loss records with an increase or 291 //decrease in size or blocks 292 } 293 LeakCheckDeltaMode; 294 295/* When a LossRecord is put into an OSet, these elements represent the key. */ 296typedef 297 struct _LossRecordKey { 298 Reachedness state; // LC_Extra.state value shared by all blocks. 299 ExeContext* allocated_at; // Where they were allocated. 300 } 301 LossRecordKey; 302 303/* A loss record, used for generating err msgs. Multiple leaked blocks can be 304 * merged into a single loss record if they have the same state and similar 305 * enough allocation points (controlled by --leak-resolution). */ 306typedef 307 struct _LossRecord { 308 LossRecordKey key; // Key, when used in an OSet. 309 SizeT szB; // Sum of all MC_Chunk.szB values. 310 SizeT indirect_szB; // Sum of all LC_Extra.indirect_szB values. 311 UInt num_blocks; // Number of blocks represented by the record. 312 SizeT old_szB; // old_* values are the values found during the 313 SizeT old_indirect_szB; // previous leak search. old_* values are used to 314 UInt old_num_blocks; // output only the changed/new loss records 315 } 316 LossRecord; 317 318typedef 319 struct _LeakCheckParams { 320 LeakCheckMode mode; 321 Bool show_reachable; 322 Bool show_possibly_lost; 323 LeakCheckDeltaMode deltamode; 324 UInt max_loss_records_output; // limit on the nr of loss records output. 325 Bool requested_by_monitor_command; // True when requested by gdb/vgdb. 326 } 327 LeakCheckParams; 328 329void MC_(detect_memory_leaks) ( ThreadId tid, LeakCheckParams * lcp); 330 331// maintains the lcp.deltamode given in the last call to detect_memory_leaks 332extern LeakCheckDeltaMode MC_(detect_memory_leaks_last_delta_mode); 333 334// prints the list of blocks corresponding to the given loss_record_nr. 335// Returns True if loss_record_nr identifies a correct loss record from last leak search. 336// Returns False otherwise. 337Bool MC_(print_block_list) ( UInt loss_record_nr); 338 339// Prints the addresses/registers/... at which a pointer to 340// the given range [address, address+szB[ is found. 341void MC_(who_points_at) ( Addr address, SizeT szB); 342 343// if delta_mode == LCD_Any, prints in buf an empty string 344// otherwise prints a delta in the layout " (+%'lu)" or " (-%'lu)" 345extern char * MC_(snprintf_delta) (char * buf, Int size, 346 SizeT current_val, SizeT old_val, 347 LeakCheckDeltaMode delta_mode); 348 349 350Bool MC_(is_valid_aligned_word) ( Addr a ); 351Bool MC_(is_within_valid_secondary) ( Addr a ); 352 353// Prints as user msg a description of the given loss record. 354void MC_(pp_LossRecord)(UInt n_this_record, UInt n_total_records, 355 LossRecord* l); 356 357 358/*------------------------------------------------------------*/ 359/*--- Errors and suppressions ---*/ 360/*------------------------------------------------------------*/ 361 362/* Did we show to the user, any errors for which an uninitialised 363 value origin could have been collected (but wasn't) ? If yes, 364 then, at the end of the run, print a 1 line message advising that a 365 rerun with --track-origins=yes might help. */ 366extern Bool MC_(any_value_errors); 367 368/* Standard functions for error and suppressions as required by the 369 core/tool iface */ 370Bool MC_(eq_Error) ( VgRes res, Error* e1, Error* e2 ); 371void MC_(before_pp_Error) ( Error* err ); 372void MC_(pp_Error) ( Error* err ); 373UInt MC_(update_Error_extra) ( Error* err ); 374 375Bool MC_(is_recognised_suppression) ( Char* name, Supp* su ); 376 377Bool MC_(read_extra_suppression_info) ( Int fd, Char** buf, 378 SizeT* nBuf, Supp *su ); 379 380Bool MC_(error_matches_suppression) ( Error* err, Supp* su ); 381 382Bool MC_(get_extra_suppression_info) ( Error* err, 383 /*OUT*/Char* buf, Int nBuf ); 384 385Char* MC_(get_error_name) ( Error* err ); 386 387/* Recording of errors */ 388void MC_(record_address_error) ( ThreadId tid, Addr a, Int szB, 389 Bool isWrite ); 390void MC_(record_cond_error) ( ThreadId tid, UInt otag ); 391void MC_(record_value_error) ( ThreadId tid, Int szB, UInt otag ); 392void MC_(record_jump_error) ( ThreadId tid, Addr a ); 393 394void MC_(record_free_error) ( ThreadId tid, Addr a ); 395void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a ); 396void MC_(record_freemismatch_error) ( ThreadId tid, MC_Chunk* mc ); 397 398void MC_(record_overlap_error) ( ThreadId tid, Char* function, 399 Addr src, Addr dst, SizeT szB ); 400void MC_(record_core_mem_error) ( ThreadId tid, Char* msg ); 401void MC_(record_regparam_error) ( ThreadId tid, Char* msg, UInt otag ); 402void MC_(record_memparam_error) ( ThreadId tid, Addr a, 403 Bool isAddrErr, Char* msg, UInt otag ); 404void MC_(record_user_error) ( ThreadId tid, Addr a, 405 Bool isAddrErr, UInt otag ); 406 407Bool MC_(record_leak_error) ( ThreadId tid, 408 UInt n_this_record, 409 UInt n_total_records, 410 LossRecord* lossRecord, 411 Bool print_record, 412 Bool count_error ); 413 414/* prints a description of address a */ 415void MC_(pp_describe_addr) (Addr a); 416 417/* Is this address in a user-specified "ignored range" ? */ 418Bool MC_(in_ignored_range) ( Addr a ); 419 420 421/*------------------------------------------------------------*/ 422/*--- Client blocks ---*/ 423/*------------------------------------------------------------*/ 424 425/* Describes a client block. See mc_main.c. An unused block has 426 start == size == 0. */ 427typedef 428 struct { 429 Addr start; 430 SizeT size; 431 ExeContext* where; 432 Char* desc; 433 } 434 CGenBlock; 435 436/* Get access to the client block array. */ 437void MC_(get_ClientBlock_array)( /*OUT*/CGenBlock** blocks, 438 /*OUT*/UWord* nBlocks ); 439 440 441/*------------------------------------------------------------*/ 442/*--- Command line options + defaults ---*/ 443/*------------------------------------------------------------*/ 444 445/* Allow loads from partially-valid addresses? default: YES */ 446extern Bool MC_(clo_partial_loads_ok); 447 448/* Max volume of the freed blocks queue. */ 449extern Long MC_(clo_freelist_vol); 450 451/* Blocks with a size >= MC_(clo_freelist_big_blocks) will be put 452 in the "big block" freed blocks queue. */ 453extern Long MC_(clo_freelist_big_blocks); 454 455/* Do leak check at exit? default: NO */ 456extern LeakCheckMode MC_(clo_leak_check); 457 458/* How closely should we compare ExeContexts in leak records? default: 2 */ 459extern VgRes MC_(clo_leak_resolution); 460 461/* In leak check, show reachable-but-not-freed blocks? default: NO */ 462extern Bool MC_(clo_show_reachable); 463 464/* In leak check, show possibly-lost blocks? default: YES */ 465extern Bool MC_(clo_show_possibly_lost); 466 467/* Assume accesses immediately below %esp are due to gcc-2.96 bugs. 468 * default: NO */ 469extern Bool MC_(clo_workaround_gcc296_bugs); 470 471/* Fill malloc-d/free-d client blocks with a specific value? -1 if 472 not, else 0x00 .. 0xFF indicating the fill value to use. Can be 473 useful for causing programs with bad heap corruption to fail in 474 more repeatable ways. Note that malloc-filled and free-filled 475 areas are still undefined and noaccess respectively. This merely 476 causes them to contain the specified values. */ 477extern Int MC_(clo_malloc_fill); 478extern Int MC_(clo_free_fill); 479 480/* Indicates the level of instrumentation/checking done by Memcheck. 481 482 1 = No undefined value checking, Addrcheck-style behaviour only: 483 only address checking is done. This is faster but finds fewer 484 errors. Note that although Addrcheck had 1 bit per byte 485 overhead vs the old Memcheck's 9 bits per byte, with this mode 486 and compressed V bits, no memory is saved with this mode -- 487 it's still 2 bits per byte overhead. This is a little wasteful 488 -- it could be done with 1 bit per byte -- but lets us reuse 489 the many shadow memory access functions. Note that in this 490 mode neither the secondary V bit table nor the origin-tag cache 491 are used. 492 493 2 = Address checking and Undefined value checking are performed, 494 but origins are not tracked. So the origin-tag cache is not 495 used in this mode. This setting is the default and corresponds 496 to the "normal" Memcheck behaviour that has shipped for years. 497 498 3 = Address checking, undefined value checking, and origins for 499 undefined values are tracked. 500 501 The default is 2. 502*/ 503extern Int MC_(clo_mc_level); 504 505 506/*------------------------------------------------------------*/ 507/*--- Instrumentation ---*/ 508/*------------------------------------------------------------*/ 509 510/* Functions defined in mc_main.c */ 511 512/* For the fail_w_o functions, the UWord arg is actually the 32-bit 513 origin tag and should really be UInt, but to be simple and safe 514 considering it's called from generated code, just claim it to be a 515 UWord. */ 516VG_REGPARM(2) void MC_(helperc_value_checkN_fail_w_o) ( HWord, UWord ); 517VG_REGPARM(1) void MC_(helperc_value_check8_fail_w_o) ( UWord ); 518VG_REGPARM(1) void MC_(helperc_value_check4_fail_w_o) ( UWord ); 519VG_REGPARM(1) void MC_(helperc_value_check1_fail_w_o) ( UWord ); 520VG_REGPARM(1) void MC_(helperc_value_check0_fail_w_o) ( UWord ); 521 522/* And call these ones instead to report an uninitialised value error 523 but with no origin available. */ 524VG_REGPARM(1) void MC_(helperc_value_checkN_fail_no_o) ( HWord ); 525VG_REGPARM(0) void MC_(helperc_value_check8_fail_no_o) ( void ); 526VG_REGPARM(0) void MC_(helperc_value_check4_fail_no_o) ( void ); 527VG_REGPARM(0) void MC_(helperc_value_check1_fail_no_o) ( void ); 528VG_REGPARM(0) void MC_(helperc_value_check0_fail_no_o) ( void ); 529 530/* V-bits load/store helpers */ 531VG_REGPARM(1) void MC_(helperc_STOREV64be) ( Addr, ULong ); 532VG_REGPARM(1) void MC_(helperc_STOREV64le) ( Addr, ULong ); 533VG_REGPARM(2) void MC_(helperc_STOREV32be) ( Addr, UWord ); 534VG_REGPARM(2) void MC_(helperc_STOREV32le) ( Addr, UWord ); 535VG_REGPARM(2) void MC_(helperc_STOREV16be) ( Addr, UWord ); 536VG_REGPARM(2) void MC_(helperc_STOREV16le) ( Addr, UWord ); 537VG_REGPARM(2) void MC_(helperc_STOREV8) ( Addr, UWord ); 538 539VG_REGPARM(1) ULong MC_(helperc_LOADV64be) ( Addr ); 540VG_REGPARM(1) ULong MC_(helperc_LOADV64le) ( Addr ); 541VG_REGPARM(1) UWord MC_(helperc_LOADV32be) ( Addr ); 542VG_REGPARM(1) UWord MC_(helperc_LOADV32le) ( Addr ); 543VG_REGPARM(1) UWord MC_(helperc_LOADV16be) ( Addr ); 544VG_REGPARM(1) UWord MC_(helperc_LOADV16le) ( Addr ); 545VG_REGPARM(1) UWord MC_(helperc_LOADV8) ( Addr ); 546 547void MC_(helperc_MAKE_STACK_UNINIT) ( Addr base, UWord len, 548 Addr nia ); 549 550/* Origin tag load/store helpers */ 551VG_REGPARM(2) void MC_(helperc_b_store1) ( Addr a, UWord d32 ); 552VG_REGPARM(2) void MC_(helperc_b_store2) ( Addr a, UWord d32 ); 553VG_REGPARM(2) void MC_(helperc_b_store4) ( Addr a, UWord d32 ); 554VG_REGPARM(2) void MC_(helperc_b_store8) ( Addr a, UWord d32 ); 555VG_REGPARM(2) void MC_(helperc_b_store16)( Addr a, UWord d32 ); 556VG_REGPARM(2) void MC_(helperc_b_store32)( Addr a, UWord d32 ); 557VG_REGPARM(1) UWord MC_(helperc_b_load1) ( Addr a ); 558VG_REGPARM(1) UWord MC_(helperc_b_load2) ( Addr a ); 559VG_REGPARM(1) UWord MC_(helperc_b_load4) ( Addr a ); 560VG_REGPARM(1) UWord MC_(helperc_b_load8) ( Addr a ); 561VG_REGPARM(1) UWord MC_(helperc_b_load16)( Addr a ); 562VG_REGPARM(1) UWord MC_(helperc_b_load32)( Addr a ); 563 564/* Functions defined in mc_translate.c */ 565IRSB* MC_(instrument) ( VgCallbackClosure* closure, 566 IRSB* bb_in, 567 VexGuestLayout* layout, 568 VexGuestExtents* vge, 569 IRType gWordTy, IRType hWordTy ); 570 571IRSB* MC_(final_tidy) ( IRSB* ); 572 573#endif /* ndef __MC_INCLUDE_H */ 574 575/*--------------------------------------------------------------------*/ 576/*--- end ---*/ 577/*--------------------------------------------------------------------*/ 578