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