1/*--------------------------------------------------------------------*/ 2/*--- Callgrind ---*/ 3/*--- global.h ---*/ 4/*--- (C) 2004, 2005 Josef Weidendorfer ---*/ 5/*--------------------------------------------------------------------*/ 6 7#ifndef CLG_GLOBAL 8#define CLG_GLOBAL 9 10#include "pub_tool_basics.h" 11#include "pub_tool_vki.h" 12#include "pub_tool_debuginfo.h" 13#include "pub_tool_libcbase.h" 14#include "pub_tool_libcassert.h" 15#include "pub_tool_libcfile.h" 16#include "pub_tool_libcprint.h" 17#include "pub_tool_libcproc.h" 18#include "pub_tool_machine.h" 19#include "pub_tool_mallocfree.h" 20#include "pub_tool_options.h" 21#include "pub_tool_tooliface.h" 22#include "pub_tool_xarray.h" 23#include "pub_tool_clientstate.h" 24#include "pub_tool_machine.h" // VG_(fnptr_to_fnentry) 25 26#include "events.h" // defines CLG_ macro 27#include "costs.h" 28 29 30/*------------------------------------------------------------*/ 31/*--- Calltree compile options --- */ 32/*------------------------------------------------------------*/ 33 34/* Enable debug output */ 35#define CLG_ENABLE_DEBUG 1 36 37/* Enable experimental features? */ 38#define CLG_EXPERIMENTAL 0 39 40/* Syscall Timing in microseconds? 41 * (define to 0 if you get compile errors) */ 42#define CLG_MICROSYSTIME 0 43 44/* Set to 1 if you want full sanity checks for JCC */ 45#define JCC_CHECK 0 46 47 48 49/*------------------------------------------------------------*/ 50/*--- Command line options ---*/ 51/*------------------------------------------------------------*/ 52 53#define DEFAULT_OUTFORMAT "callgrind.out.%p" 54#define DEFAULT_COMMANDNAME "callgrind.cmd" 55#define DEFAULT_RESULTNAME "callgrind.res" 56#define DEFAULT_INFONAME "callgrind.info" 57 58typedef struct _CommandLineOptions CommandLineOptions; 59struct _CommandLineOptions { 60 61 /* Dump format options */ 62 Char* out_format; /* Format string for callgrind output file name */ 63 Bool combine_dumps; /* Dump trace parts into same file? */ 64 Bool compress_strings; 65 Bool compress_events; 66 Bool compress_pos; 67 Bool mangle_names; 68 Bool compress_mangled; 69 Bool dump_line; 70 Bool dump_instr; 71 Bool dump_bb; 72 Bool dump_bbs; /* Dump basic block information? */ 73 74 /* Dump generation options */ 75 ULong dump_every_bb; /* Dump every xxx BBs. */ 76 77 /* Collection options */ 78 Bool separate_threads; /* Separate threads in dump? */ 79 Int separate_callers; /* Separate dependent on how many callers? */ 80 Int separate_recursions; /* Max level of recursions to separate */ 81 Bool skip_plt; /* Skip functions in PLT section? */ 82 Bool skip_direct_recursion; /* Increment direct recursions the level? */ 83 84 Bool collect_atstart; /* Start in collecting state ? */ 85 Bool collect_jumps; /* Collect (cond.) jumps in functions ? */ 86 87 Bool collect_alloc; /* Collect size of allocated memory */ 88 Bool collect_systime; /* Collect time for system calls */ 89 90 Bool collect_bus; /* Collect global bus events */ 91 92 /* Instrument options */ 93 Bool instrument_atstart; /* Instrument at start? */ 94 Bool simulate_cache; /* Call into cache simulator ? */ 95 Bool simulate_branch; /* Call into branch prediction simulator ? */ 96 97 /* Call graph generation */ 98 Bool pop_on_jump; /* Handle a jump between functions as ret+call */ 99 100#if CLG_ENABLE_DEBUG 101 Int verbose; 102 ULong verbose_start; 103#endif 104}; 105 106/*------------------------------------------------------------*/ 107/*--- Constants ---*/ 108/*------------------------------------------------------------*/ 109 110 111/* According to IA-32 Intel Architecture Software Developer's Manual: Vol 2 */ 112#define MAX_x86_INSTR_SIZE 16 113 114/* Minimum cache line size allowed */ 115#define MIN_LINE_SIZE 16 116 117/* Size of various buffers used for storing strings */ 118#define FILENAME_LEN VKI_PATH_MAX 119#define FN_NAME_LEN 4096 /* for C++ code :-) */ 120#define OBJ_NAME_LEN 256 121#define COSTS_LEN 512 /* at least 17x 64bit values */ 122#define BUF_LEN 512 123#define COMMIFY_BUF_LEN 128 124#define RESULTS_BUF_LEN 256 125#define LINE_BUF_LEN 64 126 127 128/* Convenience macros */ 129 130/* Use this only when size of sprintf args are known to fit into 131 * given buffer; for strings of unknown length, use WRITE_STR below 132 */ 133#define WRITE_SPRINTF(fd, zz_buf, fmt, args...) \ 134 do { Int len = VG_(sprintf)(zz_buf, fmt, ## args); \ 135 VG_(write)(fd, (void*)zz_buf, len); \ 136 } while (0) 137 138#define WRITE_STR(fd, str) \ 139 do { if (str) { Int len = VG_(strlen)(str); \ 140 VG_(write)(fd, (void*)str, len); } \ 141 else VG_(write)(fd, "(null)", 6); \ 142 } while (0) 143 144#define WRITE_STR2(fd, str1, str2) \ 145 do { if (str1) { Int len = VG_(strlen)(str1); \ 146 VG_(write)(fd, (void*)str1, len); } \ 147 else VG_(write)(fd, "(null)", 6); \ 148 if (str2) { Int len = VG_(strlen)(str2); \ 149 VG_(write)(fd, (void*)str2, len); } \ 150 else VG_(write)(fd, "(null)", 6); \ 151 } while (0) 152 153#define WRITE_STR3(fd, str1, str2, str3) \ 154 do { if (str1) { Int len = VG_(strlen)(str1); \ 155 VG_(write)(fd, (void*)str1, len); } \ 156 else VG_(write)(fd, "(null)", 6); \ 157 if (str2) { Int len = VG_(strlen)(str2); \ 158 VG_(write)(fd, (void*)str2, len); } \ 159 else VG_(write)(fd, "(null)", 6); \ 160 if (str3) { Int len = VG_(strlen)(str3); \ 161 VG_(write)(fd, (void*)str3, len); } \ 162 else VG_(write)(fd, "(null)", 6); \ 163 } while (0) 164 165 166/*------------------------------------------------------------*/ 167/*--- Statistics ---*/ 168/*------------------------------------------------------------*/ 169 170typedef struct _Statistics Statistics; 171struct _Statistics { 172 ULong call_counter; 173 ULong jcnd_counter; 174 ULong jump_counter; 175 ULong rec_call_counter; 176 ULong ret_counter; 177 ULong bb_executions; 178 179 Int context_counter; 180 Int bb_retranslations; 181 182 Int distinct_objs; 183 Int distinct_files; 184 Int distinct_fns; 185 Int distinct_contexts; 186 Int distinct_bbs; 187 Int distinct_jccs; 188 Int distinct_bbccs; 189 Int distinct_instrs; 190 Int distinct_skips; 191 192 Int bb_hash_resizes; 193 Int bbcc_hash_resizes; 194 Int jcc_hash_resizes; 195 Int cxt_hash_resizes; 196 Int fn_array_resizes; 197 Int call_stack_resizes; 198 Int fn_stack_resizes; 199 200 Int full_debug_BBs; 201 Int file_line_debug_BBs; 202 Int fn_name_debug_BBs; 203 Int no_debug_BBs; 204 Int bbcc_lru_misses; 205 Int jcc_lru_misses; 206 Int cxt_lru_misses; 207 Int bbcc_clones; 208}; 209 210 211/*------------------------------------------------------------*/ 212/*--- Structure declarations ---*/ 213/*------------------------------------------------------------*/ 214 215typedef struct _Context Context; 216typedef struct _CC CC; 217typedef struct _BB BB; 218typedef struct _Skipped Skipped; 219typedef struct _BBCC BBCC; 220typedef struct _jCC jCC; 221typedef struct _fCC fCC; 222typedef struct _fn_node fn_node; 223typedef struct _file_node file_node; 224typedef struct _obj_node obj_node; 225typedef struct _fn_config fn_config; 226typedef struct _call_entry call_entry; 227typedef struct _thread_info thread_info; 228 229/* Costs of event sets. Aliases to arrays of 64-bit values */ 230typedef ULong* SimCost; /* All events the simulator can produce */ 231typedef ULong* UserCost; 232typedef ULong* FullCost; /* Simulator + User */ 233 234 235/* JmpCall cost center 236 * for subroutine call (from->bb->jmp_addr => to->bb->addr) 237 * 238 * Each BB has at most one CALL instruction. The list of JCC from 239 * this call is a pointer to the list head (stored in BBCC), and 240 * <next_from> in the JCC struct. 241 * 242 * For fast lookup, JCCs are reachable with a hash table, keyed by 243 * the (from_bbcc,to) pair. <next_hash> is used for the JCC chain 244 * of one hash table entry. 245 * 246 * Cost <sum> holds event counts for already returned executions. 247 * <last> are the event counters at last enter of the subroutine. 248 * <sum> is updated on returning from the subroutine by 249 * adding the diff of <last> and current event counters to <sum>. 250 * 251 * After updating, <last> is set to current event counters. Thus, 252 * events are not counted twice for recursive calls (TODO: True?) 253 */ 254#define JmpNone (Ijk_Boring+30) 255#define JmpCond (Ijk_Boring+31) 256 257struct _jCC { 258 Int jmpkind; /* JmpCall, JmpBoring, JmpCond */ 259 jCC* next_hash; /* for hash entry chain */ 260 jCC* next_from; /* next JCC from a BBCC */ 261 BBCC *from, *to; /* call arc from/to this BBCC */ 262 UInt jmp; /* jump no. in source */ 263 264 ULong call_counter; /* no wraparound with 64 bit */ 265 266 FullCost cost; /* simulator + user counters */ 267}; 268 269 270/* 271 * Info for one instruction of a basic block. 272 */ 273typedef struct _InstrInfo InstrInfo; 274struct _InstrInfo { 275 UInt instr_offset; 276 UInt instr_size; 277 UInt cost_offset; 278 EventSet* eventset; 279}; 280 281 282/* 283 * Info for a conditional jump in a basic block 284 */ 285typedef struct _CJmpInfo CJmpInfo; 286struct _CJmpInfo { 287 UInt instr; /* instruction index in this basic block */ 288 Bool skip; /* Cond.Jumps to next instruction should be ignored */ 289}; 290 291 292/** 293 * An instrumented basic block (BB). 294 * 295 * BBs are put into a resizable hash to allow for fast detection if a 296 * BB is to be retranslated but cost info is already available. 297 * The key for a BB is a (object, offset) tupel making it independent 298 * from possibly multiple mappings of the same ELF object. 299 * 300 * At the beginning of each instrumented BB, 301 * a call to setup_bbcc(), specifying a pointer to the 302 * according BB structure, is added. 303 * 304 * As cost of a BB has to be distinguished depending on the context, 305 * multiple cost centers for one BB (struct BBCC) exist and the according 306 * BBCC is set by setup_bbcc. 307 */ 308struct _BB { 309 obj_node* obj; /* ELF object of BB */ 310 PtrdiffT offset; /* offset of BB in ELF object file */ 311 BB* next; /* chaining for a hash entry */ 312 313 VgSectKind sect_kind; /* section of this BB, e.g. PLT */ 314 UInt instr_count; 315 316 /* filled by CLG_(get_fn_node) if debug info is available */ 317 fn_node* fn; /* debug info for this BB */ 318 UInt line; 319 Bool is_entry; /* True if this BB is a function entry */ 320 321 BBCC* bbcc_list; /* BBCCs for same BB (see next_bbcc in BBCC) */ 322 BBCC* last_bbcc; /* Temporary: Cached for faster access (LRU) */ 323 324 /* filled by CLG_(instrument) if not seen before */ 325 UInt cjmp_count; /* number of conditional exits */ 326 CJmpInfo* jmp; /* array of info for condition jumps, 327 * allocated directly after this struct */ 328 Int jmpkind; /* remember jump kind of final exit */ 329 Bool cjmp_inverted; /* condition of last cond.jump can be inverted by VEX */ 330 331 UInt instr_len; 332 UInt cost_count; 333 InstrInfo instr[0]; /* info on instruction sizes and costs */ 334}; 335 336 337 338/** 339 * Function context 340 * 341 * Basic blocks are always executed in the scope of a context. 342 * A function context is a list of function nodes representing 343 * the call chain to the current context: I.e. fn[0] is the 344 * function we are currently in, fn[1] has called fn[0], and so on. 345 * Recursion levels are used for fn[0]. 346 * 347 * To get a unique number for a full execution context, use 348 * rec_index = min(<fn->rec_separation>,<active>) - 1; 349 * unique_no = <number> + rec_index 350 * 351 * For each Context, recursion index and BB, there can be a BBCC. 352 */ 353struct _Context { 354 UInt size; // number of function dependencies 355 UInt base_number; // for context compression & dump array 356 Context* next; // entry chaining for hash 357 UWord hash; // for faster lookup... 358 fn_node* fn[0]; 359}; 360 361 362/* 363 * Info for a conditional jump in a basic block 364 */ 365typedef struct _JmpData JmpData; 366struct _JmpData { 367 ULong ecounter; /* number of times the BB was left at this exit */ 368 jCC* jcc_list; /* JCCs for Cond.Jumps from this exit */ 369}; 370 371 372/* 373 * Basic Block Cost Center 374 * 375 * On demand, multiple BBCCs will be created for the same BB 376 * dependend on command line options and: 377 * - current function (it's possible that a BB is executed in the 378 * context of different functions, e.g. in manual assembler/PLT) 379 * - current thread ID 380 * - position where current function is called from 381 * - recursion level of current function 382 * 383 * The cost centres for the instructions of a basic block are 384 * stored in a contiguous array. 385 * They are distinguishable by their tag field. 386 */ 387struct _BBCC { 388 BB* bb; /* BB for this cost center */ 389 390 Context* cxt; /* execution context of this BBCC */ 391 ThreadId tid; /* only for assertion check purpose */ 392 UInt rec_index; /* Recursion index in rec->bbcc for this bbcc */ 393 BBCC** rec_array; /* Variable sized array of pointers to 394 * recursion BBCCs. Shared. */ 395 ULong ret_counter; /* how often returned from jccs of this bbcc; 396 * used to check if a dump for this BBCC is needed */ 397 398 BBCC* next_bbcc; /* Chain of BBCCs for same BB */ 399 BBCC* lru_next_bbcc; /* BBCC executed next the last time */ 400 401 jCC* lru_from_jcc; /* Temporary: Cached for faster access (LRU) */ 402 jCC* lru_to_jcc; /* Temporary: Cached for faster access (LRU) */ 403 FullCost skipped; /* cost for skipped functions called from 404 * jmp_addr. Allocated lazy */ 405 406 BBCC* next; /* entry chain in hash */ 407 ULong* cost; /* start of 64bit costs for this BBCC */ 408 ULong ecounter_sum; /* execution counter for first instruction of BB */ 409 JmpData jmp[0]; 410}; 411 412 413/* the <number> of fn_node, file_node and obj_node are for compressed dumping 414 * and a index into the dump boolean table and fn_info_table 415 */ 416 417struct _fn_node { 418 Char* name; 419 UInt number; 420 Context* last_cxt; /* LRU info */ 421 Context* pure_cxt; /* the context with only the function itself */ 422 file_node* file; /* reverse mapping for 2nd hash */ 423 fn_node* next; 424 425 Bool dump_before :1; 426 Bool dump_after :1; 427 Bool zero_before :1; 428 Bool toggle_collect :1; 429 Bool skip :1; 430 Bool pop_on_jump : 1; 431 432 Bool is_malloc :1; 433 Bool is_realloc :1; 434 Bool is_free :1; 435 436 Int group; 437 Int separate_callers; 438 Int separate_recursions; 439#if CLG_ENABLE_DEBUG 440 Int verbosity; /* Stores old verbosity level while in function */ 441#endif 442}; 443 444/* Quite arbitrary fixed hash sizes */ 445 446#define N_OBJ_ENTRIES 47 447#define N_FILE_ENTRIES 53 448#define N_FN_ENTRIES 87 449#define N_BBCC2_ENTRIES 37 450 451struct _file_node { 452 Char* name; 453 fn_node* fns[N_FN_ENTRIES]; 454 UInt number; 455 obj_node* obj; 456 file_node* next; 457}; 458 459/* If an object is dlopened multiple times, we hope that <name> is unique; 460 * <start> and <offset> can change with each dlopen, and <start> is 461 * zero when object is unmapped (possible at dump time). 462 */ 463struct _obj_node { 464 Char* name; 465 UInt last_slash_pos; 466 467 Addr start; /* Start address of text segment mapping */ 468 SizeT size; /* Length of mapping */ 469 PtrdiffT offset; /* Offset between symbol address and file offset */ 470 471 file_node* files[N_FILE_ENTRIES]; 472 UInt number; 473 obj_node* next; 474}; 475 476/* an entry in the callstack 477 * 478 * <nonskipped> is 0 if the function called is not skipped (usual case). 479 * Otherwise, it is the last non-skipped BBCC. This one gets all 480 * the calls to non-skipped functions and all costs in skipped 481 * instructions. 482 */ 483struct _call_entry { 484 jCC* jcc; /* jCC for this call */ 485 FullCost enter_cost; /* cost event counters at entering frame */ 486 Addr sp; /* stack pointer directly after call */ 487 Addr ret_addr; /* address to which to return to 488 * is 0 on a simulated call */ 489 BBCC* nonskipped; /* see above */ 490 Context* cxt; /* context before call */ 491 Int fn_sp; /* function stack index before call */ 492}; 493 494 495/* 496 * Execution state of main thread or a running signal handler in 497 * a thread while interrupted by another signal handler. 498 * As there's no scheduling among running signal handlers of one thread, 499 * we only need a subset of a full thread state: 500 * - event counter 501 * - collect state 502 * - last BB, last jump kind, last nonskipped BB 503 * - callstack pointer for sanity checking and correct unwinding 504 * after exit 505 */ 506typedef struct _exec_state exec_state; 507struct _exec_state { 508 509 /* the signum of the handler, 0 for main thread context 510 */ 511 Int sig; 512 513 /* the old call stack pointer at entering the signal handler */ 514 Int orig_sp; 515 516 FullCost cost; 517 Bool collect; 518 Context* cxt; 519 520 Int jmps_passed; /* number of conditional jumps passed in last BB */ 521 BBCC* bbcc; /* last BB executed */ 522 BBCC* nonskipped; 523 524 Int call_stack_bottom; /* Index into fn_stack */ 525}; 526 527/* Global state structures */ 528typedef struct _bb_hash bb_hash; 529struct _bb_hash { 530 UInt size, entries; 531 BB** table; 532}; 533 534typedef struct _cxt_hash cxt_hash; 535struct _cxt_hash { 536 UInt size, entries; 537 Context** table; 538}; 539 540/* Thread specific state structures, i.e. parts of a thread state. 541 * There are variables for the current state of each part, 542 * on which a thread state is copied at thread switch. 543 */ 544typedef struct _bbcc_hash bbcc_hash; 545struct _bbcc_hash { 546 UInt size, entries; 547 BBCC** table; 548}; 549 550typedef struct _jcc_hash jcc_hash; 551struct _jcc_hash { 552 UInt size, entries; 553 jCC** table; 554 jCC* spontaneous; 555}; 556 557typedef struct _fn_array fn_array; 558struct _fn_array { 559 UInt size; 560 UInt* array; 561}; 562 563typedef struct _call_stack call_stack; 564struct _call_stack { 565 UInt size; 566 Int sp; 567 call_entry* entry; 568}; 569 570typedef struct _fn_stack fn_stack; 571struct _fn_stack { 572 UInt size; 573 fn_node **bottom, **top; 574}; 575 576/* The maximum number of simultaneous running signal handlers per thread. 577 * This is the number of execution states storable in a thread. 578 */ 579#define MAX_SIGHANDLERS 10 580 581typedef struct _exec_stack exec_stack; 582struct _exec_stack { 583 Int sp; /* > 0 if a handler is running */ 584 exec_state* entry[MAX_SIGHANDLERS]; 585}; 586 587/* Thread State 588 * 589 * This structure stores thread specific info while a thread is *not* 590 * running. See function switch_thread() for save/restore on thread switch. 591 * 592 * If --separate-threads=no, BBCCs and JCCs can be shared by all threads, i.e. 593 * only structures of thread 1 are used. 594 * This involves variables fn_info_table, bbcc_table and jcc_table. 595 */ 596struct _thread_info { 597 598 /* state */ 599 fn_stack fns; /* function stack */ 600 call_stack calls; /* context call arc stack */ 601 exec_stack states; /* execution states interrupted by signals */ 602 603 /* dump statistics */ 604 FullCost lastdump_cost; /* Cost at last dump */ 605 FullCost sighandler_cost; 606 607 /* thread specific data structure containers */ 608 fn_array fn_active; 609 jcc_hash jccs; 610 bbcc_hash bbccs; 611}; 612 613/* Structs used for dumping */ 614 615/* Address position inside of a BBCC: 616 * This includes 617 * - the address offset from the BB start address 618 * - file/line from debug info for that address (can change inside a BB) 619 */ 620typedef struct _AddrPos AddrPos; 621struct _AddrPos { 622 Addr addr; 623 Addr bb_addr; 624 file_node* file; 625 UInt line; 626}; 627 628/* a simulator cost entity that can be written out in one line */ 629typedef struct _AddrCost AddrCost; 630struct _AddrCost { 631 AddrPos p; 632 SimCost cost; 633}; 634 635/* A function in an execution context */ 636typedef struct _FnPos FnPos; 637struct _FnPos { 638 file_node* file; 639 fn_node* fn; 640 obj_node* obj; 641 Context* cxt; 642 int rec_index; 643 UInt line; 644}; 645 646/*------------------------------------------------------------*/ 647/*--- Cache simulator interface ---*/ 648/*------------------------------------------------------------*/ 649 650struct cachesim_if 651{ 652 void (*print_opts)(void); 653 Bool (*parse_opt)(Char* arg); 654 void (*post_clo_init)(void); 655 void (*clear)(void); 656 void (*getdesc)(Char* buf); 657 void (*printstat)(Int,Int,Int); 658 void (*add_icost)(SimCost, BBCC*, InstrInfo*, ULong); 659 void (*finish)(void); 660 661 void (*log_1I0D)(InstrInfo*) VG_REGPARM(1); 662 void (*log_2I0D)(InstrInfo*, InstrInfo*) VG_REGPARM(2); 663 void (*log_3I0D)(InstrInfo*, InstrInfo*, InstrInfo*) VG_REGPARM(3); 664 665 void (*log_1I1Dr)(InstrInfo*, Addr, Word) VG_REGPARM(3); 666 void (*log_1I1Dw)(InstrInfo*, Addr, Word) VG_REGPARM(3); 667 668 void (*log_0I1Dr)(InstrInfo*, Addr, Word) VG_REGPARM(3); 669 void (*log_0I1Dw)(InstrInfo*, Addr, Word) VG_REGPARM(3); 670 671 // function names of helpers (for debugging generated code) 672 Char *log_1I0D_name, *log_2I0D_name, *log_3I0D_name; 673 Char *log_1I1Dr_name, *log_1I1Dw_name; 674 Char *log_0I1Dr_name, *log_0I1Dw_name; 675}; 676 677// set by setup_bbcc at start of every BB, and needed by log_* helpers 678extern Addr CLG_(bb_base); 679extern ULong* CLG_(cost_base); 680 681// Event groups 682#define EG_USE 0 683#define EG_IR 1 684#define EG_DR 2 685#define EG_DW 3 686#define EG_BC 4 687#define EG_BI 5 688#define EG_BUS 6 689#define EG_ALLOC 7 690#define EG_SYS 8 691 692struct event_sets { 693 EventSet *base, *full; 694}; 695extern struct event_sets CLG_(sets); 696 697#define fullOffset(group) (CLG_(sets).full->offset[group]) 698 699 700/*------------------------------------------------------------*/ 701/*--- Functions ---*/ 702/*------------------------------------------------------------*/ 703 704/* from clo.c */ 705 706void CLG_(set_clo_defaults)(void); 707void CLG_(update_fn_config)(fn_node*); 708Bool CLG_(process_cmd_line_option)(Char*); 709void CLG_(print_usage)(void); 710void CLG_(print_debug_usage)(void); 711 712/* from sim.c */ 713extern struct cachesim_if CLG_(cachesim); 714void CLG_(init_eventsets)(void); 715 716/* from main.c */ 717Bool CLG_(get_debug_info)(Addr, Char filename[FILENAME_LEN], 718 Char fn_name[FN_NAME_LEN], UInt*, DebugInfo**); 719void CLG_(collectBlockInfo)(IRSB* bbIn, UInt*, UInt*, Bool*); 720void CLG_(set_instrument_state)(Char*,Bool); 721void CLG_(dump_profile)(Char* trigger,Bool only_current_thread); 722void CLG_(zero_all_cost)(Bool only_current_thread); 723Int CLG_(get_dump_counter)(void); 724void CLG_(fini)(Int exitcode); 725 726/* from command.c */ 727void CLG_(init_command)(void); 728void CLG_(check_command)(void); 729void CLG_(finish_command)(void); 730 731/* from bb.c */ 732void CLG_(init_bb_hash)(void); 733bb_hash* CLG_(get_bb_hash)(void); 734BB* CLG_(get_bb)(Addr addr, IRSB* bb_in, Bool *seen_before); 735void CLG_(delete_bb)(Addr addr); 736 737static __inline__ Addr bb_addr(BB* bb) 738 { return bb->offset + bb->obj->offset; } 739static __inline__ Addr bb_jmpaddr(BB* bb) 740 { UInt off = (bb->instr_count > 0) ? bb->instr[bb->instr_count-1].instr_offset : 0; 741 return off + bb->offset + bb->obj->offset; } 742 743/* from fn.c */ 744void CLG_(init_fn_array)(fn_array*); 745void CLG_(copy_current_fn_array)(fn_array* dst); 746fn_array* CLG_(get_current_fn_array)(void); 747void CLG_(set_current_fn_array)(fn_array*); 748UInt* CLG_(get_fn_entry)(Int n); 749 750void CLG_(init_obj_table)(void); 751obj_node* CLG_(get_obj_node)(DebugInfo* si); 752file_node* CLG_(get_file_node)(obj_node*, Char* filename); 753fn_node* CLG_(get_fn_node)(BB* bb); 754 755/* from bbcc.c */ 756void CLG_(init_bbcc_hash)(bbcc_hash* bbccs); 757void CLG_(copy_current_bbcc_hash)(bbcc_hash* dst); 758bbcc_hash* CLG_(get_current_bbcc_hash)(void); 759void CLG_(set_current_bbcc_hash)(bbcc_hash*); 760void CLG_(forall_bbccs)(void (*func)(BBCC*)); 761void CLG_(zero_bbcc)(BBCC* bbcc); 762BBCC* CLG_(get_bbcc)(BB* bb); 763BBCC* CLG_(clone_bbcc)(BBCC* orig, Context* cxt, Int rec_index); 764void CLG_(setup_bbcc)(BB* bb) VG_REGPARM(1); 765 766 767/* from jumps.c */ 768void CLG_(init_jcc_hash)(jcc_hash*); 769void CLG_(copy_current_jcc_hash)(jcc_hash* dst); 770jcc_hash* CLG_(get_current_jcc_hash)(void); 771void CLG_(set_current_jcc_hash)(jcc_hash*); 772jCC* CLG_(get_jcc)(BBCC* from, UInt, BBCC* to); 773 774/* from callstack.c */ 775void CLG_(init_call_stack)(call_stack*); 776void CLG_(copy_current_call_stack)(call_stack* dst); 777void CLG_(set_current_call_stack)(call_stack*); 778call_entry* CLG_(get_call_entry)(Int n); 779 780void CLG_(push_call_stack)(BBCC* from, UInt jmp, BBCC* to, Addr sp, Bool skip); 781void CLG_(pop_call_stack)(void); 782Int CLG_(unwind_call_stack)(Addr sp, Int); 783 784/* from context.c */ 785void CLG_(init_fn_stack)(fn_stack*); 786void CLG_(copy_current_fn_stack)(fn_stack*); 787fn_stack* CLG_(get_current_fn_stack)(void); 788void CLG_(set_current_fn_stack)(fn_stack*); 789 790void CLG_(init_cxt_table)(void); 791cxt_hash* CLG_(get_cxt_hash)(void); 792Context* CLG_(get_cxt)(fn_node** fn); 793void CLG_(push_cxt)(fn_node* fn); 794 795/* from threads.c */ 796void CLG_(init_threads)(void); 797thread_info** CLG_(get_threads)(void); 798thread_info* CLG_(get_current_thread)(void); 799void CLG_(switch_thread)(ThreadId tid); 800void CLG_(forall_threads)(void (*func)(thread_info*)); 801void CLG_(run_thread)(ThreadId tid); 802 803void CLG_(init_exec_state)(exec_state* es); 804void CLG_(init_exec_stack)(exec_stack*); 805void CLG_(copy_current_exec_stack)(exec_stack*); 806void CLG_(set_current_exec_stack)(exec_stack*); 807void CLG_(pre_signal)(ThreadId tid, Int sigNum, Bool alt_stack); 808void CLG_(post_signal)(ThreadId tid, Int sigNum); 809void CLG_(run_post_signal_on_call_stack_bottom)(void); 810 811/* from dump.c */ 812extern FullCost CLG_(total_cost); 813void CLG_(init_dumps)(void); 814Char* CLG_(get_out_file)(void); 815Char* CLG_(get_out_directory)(void); 816 817/*------------------------------------------------------------*/ 818/*--- Exported global variables ---*/ 819/*------------------------------------------------------------*/ 820 821extern CommandLineOptions CLG_(clo); 822extern Statistics CLG_(stat); 823extern EventMapping* CLG_(dumpmap); 824 825/* Function active counter array, indexed by function number */ 826extern UInt* CLG_(fn_active_array); 827extern Bool CLG_(instrument_state); 828 829extern call_stack CLG_(current_call_stack); 830extern fn_stack CLG_(current_fn_stack); 831extern exec_state CLG_(current_state); 832extern ThreadId CLG_(current_tid); 833 834 835/*------------------------------------------------------------*/ 836/*--- Debug output ---*/ 837/*------------------------------------------------------------*/ 838 839#if CLG_ENABLE_DEBUG 840 841#define CLG_DEBUGIF(x) \ 842 if ( (CLG_(clo).verbose >x) && \ 843 (CLG_(stat).bb_executions >= CLG_(clo).verbose_start)) 844 845#define CLG_DEBUG(x,format,args...) \ 846 CLG_DEBUGIF(x) { \ 847 CLG_(print_bbno)(); \ 848 VG_(printf)(format,##args); \ 849 } 850 851#define CLG_ASSERT(cond) \ 852 if (!(cond)) { \ 853 CLG_(print_context)(); \ 854 CLG_(print_bbno)(); \ 855 tl_assert(cond); \ 856 } 857 858#else 859#define CLG_DEBUGIF(x) if (0) 860#define CLG_DEBUG(x...) {} 861#define CLG_ASSERT(cond) tl_assert(cond); 862#endif 863 864/* from debug.c */ 865void CLG_(print_bbno)(void); 866void CLG_(print_context)(void); 867void CLG_(print_jcc)(int s, jCC* jcc); 868void CLG_(print_bbcc)(int s, BBCC* bbcc); 869void CLG_(print_bbcc_fn)(BBCC* bbcc); 870void CLG_(print_execstate)(int s, exec_state* es); 871void CLG_(print_eventset)(int s, EventSet* es); 872void CLG_(print_cost)(int s, EventSet*, ULong* cost); 873void CLG_(print_bb)(int s, BB* bb); 874void CLG_(print_bbcc_cost)(int s, BBCC*); 875void CLG_(print_cxt)(int s, Context* cxt, int rec_index); 876void CLG_(print_short_jcc)(jCC* jcc); 877void CLG_(print_stackentry)(int s, int sp); 878void CLG_(print_addr)(Addr addr); 879void CLG_(print_addr_ln)(Addr addr); 880 881void* CLG_(malloc)(HChar* cc, UWord s, char* f); 882void* CLG_(free)(void* p, char* f); 883#if 0 884#define CLG_MALLOC(_cc,x) CLG_(malloc)((_cc),x,__FUNCTION__) 885#define CLG_FREE(p) CLG_(free)(p,__FUNCTION__) 886#else 887#define CLG_MALLOC(_cc,x) VG_(malloc)((_cc),x) 888#define CLG_FREE(p) VG_(free)(p) 889#endif 890 891#endif /* CLG_GLOBAL */ 892