callgrind/clo.c

   1 /*
   2    This file is part of Callgrind, a Valgrind tool for call graph
   3    profiling programs.
   4
   5    Copyright (C) 2002-2013, Josef Weidendorfer (Josef.Weidendorfer@gmx.de)
   6
   7    This tool is derived from and contains lot of code from Cachegrind
   8    Copyright (C) 2002-2013 Nicholas Nethercote (njn@valgrind.org)
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2 of the
  13    License, or (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    The GNU General Public License is contained in the file COPYING.
  26 */
  27
  28 #include "config.h" // for VG_PREFIX
  29
  30 #include "global.h"
  31
  32
  33
  34 /*------------------------------------------------------------*/
  35 /*--- Function specific configuration options              ---*/
  36 /*------------------------------------------------------------*/
  37
  38 /* Special value for separate_callers: automatic = adaptive */
  39 #define CONFIG_AUTO    -1
  40
  41 #define CONFIG_DEFAULT -1
  42 #define CONFIG_FALSE    0
  43 #define CONFIG_TRUE     1
  44
  45 /* Logging configuration for a function */
  46 struct _fn_config {
  47     Int dump_before;
  48     Int dump_after;
  49     Int zero_before;
  50     Int toggle_collect;
  51
  52     Int skip;    /* Handle CALL to this function as JMP (= Skip)? */
  53     Int group;   /* don't change caller dependency inside group !=0 */
  54     Int pop_on_jump;
  55
  56     Int separate_callers;    /* separate logging dependent on caller  */
  57     Int separate_recursions; /* separate logging of rec. levels       */
  58
  59 #if CLG_ENABLE_DEBUG
  60     Int verbosity; /* Change debug verbosity level while in function */
  61 #endif
  62 };
  63
  64 /* Configurations for function name prefix patterns.
  65  * Currently, only very limit patterns are possible:
  66  * Exact prefix patterns and "*::" are allowed.
  67  * E.g.
  68  *  - "abc" matches all functions starting with "abc".
  69  *  - "abc*::def" matches all functions starting with "abc" and
  70  *    starting with "def" after the first "::" separator.
  71  *  - "*::print(" matches C++ methods "print" in all classes
  72  *    without namespace. I.e. "*" doesn't match a "::".
  73  *
  74  * We build a trie from patterns, and for a given function, we
  75  * go down the tree and apply all non-default configurations.
  76  */
  77
  78
  79 #define NODE_DEGREE 30
  80
  81 /* node of compressed trie search structure */
  82 typedef struct _config_node config_node;
  83 struct _config_node {
  84   Int length;
  85
  86   fn_config* config;
  87   config_node* sub_node[NODE_DEGREE];
  88   config_node* next;
  89   config_node* wild_star;
  90   config_node* wild_char;
  91
  92   HChar name[1];
  93 };
  94
  95 /* root of trie */
  96 static config_node* fn_configs = 0;
  97
  98 static __inline__
  99 fn_config* new_fnc(void)
 100 {
 101    fn_config* fnc = (fn_config*) CLG_MALLOC("cl.clo.nf.1",
 102                                             sizeof(fn_config));
 103
 104    fnc->dump_before  = CONFIG_DEFAULT;
 105    fnc->dump_after   = CONFIG_DEFAULT;
 106    fnc->zero_before  = CONFIG_DEFAULT;
 107    fnc->toggle_collect = CONFIG_DEFAULT;
 108    fnc->skip         = CONFIG_DEFAULT;
 109    fnc->pop_on_jump  = CONFIG_DEFAULT;
 110    fnc->group        = CONFIG_DEFAULT;
 111    fnc->separate_callers    = CONFIG_DEFAULT;
 112    fnc->separate_recursions = CONFIG_DEFAULT;
 113
 114 #if CLG_ENABLE_DEBUG
 115    fnc->verbosity    = CONFIG_DEFAULT;
 116 #endif
 117
 118    return fnc;
 119 }
 120
 121
 122 static config_node* new_config(const HChar* name, int length)
 123 {
 124     int i;
 125     config_node* node = (config_node*) CLG_MALLOC("cl.clo.nc.1",
 126                                                   sizeof(config_node) + length);
 127
 128     for(i=0;i<length;i++) {
 129       if (name[i] == 0) break;
 130       node->name[i] = name[i];
 131     }
 132     node->name[i] = 0;
 133
 134     node->length = length;
 135     node->config = 0;
 136     for(i=0;i<NODE_DEGREE;i++)
 137         node->sub_node[i] = 0;
 138     node->next = 0;
 139     node->wild_char = 0;
 140     node->wild_star = 0;
 141
 142     CLG_DEBUG(3, "   new_config('%s', len %d)\n", node->name, length);
 143
 144     return node;
 145 }
 146
 147 static __inline__
 148 Bool is_wild(HChar n)
 149 {
 150   return (n == '*') || (n == '?');
 151 }
 152
 153 /* Recursively build up function matching tree (prefix tree).
 154  * Returns function config object for pattern <name>
 155  * and starting at tree node <*pnode>.
 156  *
 157  * Tree nodes (config_node) are created as needed,
 158  * tree root is stored into <*pnode>, and the created
 159  * leaf (fn_config) for the given pattern is returned.
 160  */
 161 static fn_config* get_fnc2(config_node* node, const HChar* name)
 162 {
 163   config_node *new_sub, *n, *nprev;
 164   int offset, len;
 165
 166   CLG_DEBUG(3, "  get_fnc2(%p, '%s')\n", node, name);
 167
 168   if (name[0] == 0) {
 169     if (!node->config) node->config = new_fnc();
 170     return node->config;
 171   }
 172
 173   if (is_wild(*name)) {
 174     if (*name == '*') {
 175       while(name[1] == '*') name++;
 176       new_sub = node->wild_star;
 177     }
 178     else
 179       new_sub = node->wild_char;
 180
 181     if (!new_sub) {
 182       new_sub = new_config(name, 1);
 183       if (*name == '*')
 184         node->wild_star = new_sub;
 185       else
 186         node->wild_char = new_sub;
 187     }
 188
 189     return get_fnc2( new_sub, name+1);
 190   }
 191
 192   n = node->sub_node[ name[0]%NODE_DEGREE ];
 193   nprev = 0;
 194   len = 0;
 195   while(n) {
 196     for(len=0; name[len] == n->name[len]; len++);
 197     if (len>0) break;
 198     nprev = n;
 199     n = n->next;
 200   }
 201
 202   if (!n) {
 203     len = 1;
 204     while(name[len] && (!is_wild(name[len]))) len++;
 205     new_sub = new_config(name, len);
 206     new_sub->next = node->sub_node[ name[0]%NODE_DEGREE ];
 207     node->sub_node[ name[0]%NODE_DEGREE ] = new_sub;
 208
 209     if (name[len] == 0) {
 210       new_sub->config = new_fnc();
 211       return new_sub->config;
 212     }
 213
 214     /* recurse on wildcard */
 215     return get_fnc2( new_sub, name+len);
 216   }
 217
 218   if (len < n->length) {
 219
 220     /* split up the subnode <n> */
 221     config_node *new_node;
 222     int i;
 223
 224     new_node = new_config(n->name, len);
 225     if (nprev)
 226       nprev->next = new_node;
 227     else
 228       node->sub_node[ n->name[0]%NODE_DEGREE ] = new_node;
 229     new_node->next = n->next;
 230
 231     new_node->sub_node[ n->name[len]%NODE_DEGREE ] = n;
 232
 233     for(i=0, offset=len; offset < n->length; i++, offset++)
 234       n->name[i] = n->name[offset];
 235     n->name[i] = 0;
 236     n->length = i;
 237
 238     name += len;
 239     offset = 0;
 240     while(name[offset] && (!is_wild(name[offset]))) offset++;
 241     new_sub  = new_config(name, offset);
 242     /* this sub_node of new_node could already be set: chain! */
 243     new_sub->next = new_node->sub_node[ name[0]%NODE_DEGREE ];
 244     new_node->sub_node[ name[0]%NODE_DEGREE ] = new_sub;
 245
 246     if (name[offset]==0) {
 247       new_sub->config = new_fnc();
 248       return new_sub->config;
 249     }
 250
 251     /* recurse on wildcard */
 252     return get_fnc2( new_sub, name+offset);
 253   }
 254
 255   name += n->length;
 256
 257   if (name[0] == 0) {
 258     /* name and node name are the same */
 259     if (!n->config) n->config = new_fnc();
 260     return n->config;
 261   }
 262
 263   offset = 1;
 264   while(name[offset] && (!is_wild(name[offset]))) offset++;
 265
 266   new_sub = new_config(name, offset);
 267   new_sub->next = n->sub_node[ name[0]%NODE_DEGREE ];
 268   n->sub_node[ name[0]%NODE_DEGREE ] = new_sub;
 269
 270   return get_fnc2(new_sub, name+offset);
 271 }
 272
 273 static void print_config_node(int depth, int hash, config_node* node)
 274 {
 275   config_node* n;
 276   int i;
 277
 278   if (node != fn_configs) {
 279     const HChar sp[] = "                                        ";
 280
 281     if (depth>40) depth=40;
 282     VG_(printf)("%s", sp+40-depth);
 283     if (hash >=0) VG_(printf)(" [hash %2d]", hash);
 284     else if (hash == -2) VG_(printf)(" [wildc ?]");
 285     else if (hash == -3) VG_(printf)(" [wildc *]");
 286     VG_(printf)(" '%s' (len %d)\n", node->name, node->length);
 287   }
 288   for(i=0;i<NODE_DEGREE;i++) {
 289     n = node->sub_node[i];
 290     while(n) {
 291       print_config_node(depth+1, i, n);
 292       n = n->next;
 293     }
 294   }
 295   if (node->wild_char) print_config_node(depth+1, -2, node->wild_char);
 296   if (node->wild_star) print_config_node(depth+1, -3, node->wild_star);
 297 }
 298
 299 /* get a function config for a name pattern (from command line) */
 300 static fn_config* get_fnc(const HChar* name)
 301 {
 302   fn_config* fnc;
 303
 304   CLG_DEBUG(3, " +get_fnc(%s)\n", name);
 305   if (fn_configs == 0)
 306     fn_configs = new_config(name, 0);
 307   fnc =  get_fnc2(fn_configs, name);
 308
 309   CLG_DEBUGIF(3) {
 310     CLG_DEBUG(3, " -get_fnc(%s):\n", name);
 311     print_config_node(3, -1, fn_configs);
 312   }
 313   return fnc;
 314 }
 315
 316
 317
 318 static void update_fn_config1(fn_node* fn, fn_config* fnc)
 319 {
 320     if (fnc->dump_before != CONFIG_DEFAULT)
 321         fn->dump_before = (fnc->dump_before == CONFIG_TRUE);
 322
 323     if (fnc->dump_after != CONFIG_DEFAULT)
 324         fn->dump_after = (fnc->dump_after == CONFIG_TRUE);
 325
 326     if (fnc->zero_before != CONFIG_DEFAULT)
 327         fn->zero_before = (fnc->zero_before == CONFIG_TRUE);
 328
 329     if (fnc->toggle_collect != CONFIG_DEFAULT)
 330         fn->toggle_collect = (fnc->toggle_collect == CONFIG_TRUE);
 331
 332     if (fnc->skip != CONFIG_DEFAULT)
 333         fn->skip = (fnc->skip == CONFIG_TRUE);
 334
 335     if (fnc->pop_on_jump != CONFIG_DEFAULT)
 336         fn->pop_on_jump = (fnc->pop_on_jump == CONFIG_TRUE);
 337
 338     if (fnc->group != CONFIG_DEFAULT)
 339         fn->group = fnc->group;
 340
 341     if (fnc->separate_callers != CONFIG_DEFAULT)
 342         fn->separate_callers = fnc->separate_callers;
 343
 344     if (fnc->separate_recursions != CONFIG_DEFAULT)
 345         fn->separate_recursions = fnc->separate_recursions;
 346
 347 #if CLG_ENABLE_DEBUG
 348     if (fnc->verbosity != CONFIG_DEFAULT)
 349         fn->verbosity = fnc->verbosity;
 350 #endif
 351 }
 352
 353 /* Recursively go down the function matching tree,
 354  * looking for a match to <name>. For every matching leaf,
 355  * <fn> is updated with the pattern config.
 356  */
 357 static void update_fn_config2(fn_node* fn, const HChar* name,
 358                               config_node* node)
 359 {
 360     config_node* n;
 361
 362     CLG_DEBUG(3, "  update_fn_config2('%s', node '%s'): \n",
 363              name, node->name);
 364     if ((*name == 0) && node->config) {
 365       CLG_DEBUG(3, "   found!\n");
 366       update_fn_config1(fn, node->config);
 367       return;
 368     }
 369
 370     n = node->sub_node[ name[0]%NODE_DEGREE ];
 371     while(n) {
 372       if (VG_(strncmp)(name, n->name, n->length)==0) break;
 373       n = n->next;
 374     }
 375     if (n) {
 376         CLG_DEBUG(3, "   '%s' matching at hash %d\n",
 377                   n->name, name[0]%NODE_DEGREE);
 378         update_fn_config2(fn, name+n->length, n);
 379     }
 380
 381     if (node->wild_char) {
 382         CLG_DEBUG(3, "   skip '%c' for wildcard '?'\n", *name);
 383         update_fn_config2(fn, name+1, node->wild_char);
 384     }
 385
 386     if (node->wild_star) {
 387       CLG_DEBUG(3, "   wildcard '*'\n");
 388       while(*name) {
 389         update_fn_config2(fn, name, node->wild_star);
 390         name++;
 391       }
 392       update_fn_config2(fn, name, node->wild_star);
 393     }
 394 }
 395
 396 /* Update function config according to configs of name prefixes */
 397 void CLG_(update_fn_config)(fn_node* fn)
 398 {
 399     CLG_DEBUG(3, "  update_fn_config('%s')\n", fn->name);
 400     if (fn_configs)
 401       update_fn_config2(fn, fn->name, fn_configs);
 402 }
 403
 404
 405 /*--------------------------------------------------------------------*/
 406 /*--- Command line processing                                      ---*/
 407 /*--------------------------------------------------------------------*/
 408
 409 Bool CLG_(process_cmd_line_option)(const HChar* arg)
 410 {
 411    const HChar* tmp_str;
 412
 413    if      VG_BOOL_CLO(arg, "--skip-plt", CLG_(clo).skip_plt) {}
 414
 415    else if VG_BOOL_CLO(arg, "--collect-jumps", CLG_(clo).collect_jumps) {}
 416    /* compatibility alias, deprecated option */
 417    else if VG_BOOL_CLO(arg, "--trace-jump",    CLG_(clo).collect_jumps) {}
 418
 419    else if VG_BOOL_CLO(arg, "--combine-dumps", CLG_(clo).combine_dumps) {}
 420
 421    else if VG_BOOL_CLO(arg, "--collect-atstart", CLG_(clo).collect_atstart) {}
 422
 423    else if VG_BOOL_CLO(arg, "--instr-atstart", CLG_(clo).instrument_atstart) {}
 424
 425    else if VG_BOOL_CLO(arg, "--separate-threads", CLG_(clo).separate_threads) {}
 426
 427    else if VG_BOOL_CLO(arg, "--compress-strings", CLG_(clo).compress_strings) {}
 428    else if VG_BOOL_CLO(arg, "--compress-mangled", CLG_(clo).compress_mangled) {}
 429    else if VG_BOOL_CLO(arg, "--compress-pos",     CLG_(clo).compress_pos) {}
 430
 431    else if VG_STR_CLO(arg, "--fn-skip", tmp_str) {
 432        fn_config* fnc = get_fnc(tmp_str);
 433        fnc->skip = CONFIG_TRUE;
 434    }
 435
 436    else if VG_STR_CLO(arg, "--dump-before", tmp_str) {
 437        fn_config* fnc = get_fnc(tmp_str);
 438        fnc->dump_before = CONFIG_TRUE;
 439    }
 440
 441    else if VG_STR_CLO(arg, "--zero-before", tmp_str) {
 442        fn_config* fnc = get_fnc(tmp_str);
 443        fnc->zero_before = CONFIG_TRUE;
 444    }
 445
 446    else if VG_STR_CLO(arg, "--dump-after", tmp_str) {
 447        fn_config* fnc = get_fnc(tmp_str);
 448        fnc->dump_after = CONFIG_TRUE;
 449    }
 450
 451    else if VG_STR_CLO(arg, "--toggle-collect", tmp_str) {
 452        fn_config* fnc = get_fnc(tmp_str);
 453        fnc->toggle_collect = CONFIG_TRUE;
 454        /* defaults to initial collection off */
 455        CLG_(clo).collect_atstart = False;
 456    }
 457
 458    else if VG_INT_CLO(arg, "--separate-recs", CLG_(clo).separate_recursions) {}
 459
 460    /* change handling of a jump between functions to ret+call */
 461    else if VG_XACT_CLO(arg, "--pop-on-jump", CLG_(clo).pop_on_jump, True) {}
 462    else if VG_STR_CLO( arg, "--pop-on-jump", tmp_str) {
 463        fn_config* fnc = get_fnc(tmp_str);
 464        fnc->pop_on_jump = CONFIG_TRUE;
 465    }
 466
 467 #if CLG_ENABLE_DEBUG
 468    else if VG_INT_CLO(arg, "--ct-verbose", CLG_(clo).verbose) {}
 469    else if VG_INT_CLO(arg, "--ct-vstart",  CLG_(clo).verbose_start) {}
 470
 471    else if VG_STREQN(12, arg, "--ct-verbose") {
 472        fn_config* fnc;
 473        HChar* s;
 474        UInt n = VG_(strtoll10)(arg+12, &s);
 475        if ((n <= 0) || *s != '=') return False;
 476        fnc = get_fnc(s+1);
 477        fnc->verbosity = n;
 478    }
 479 #endif
 480
 481    else if VG_XACT_CLO(arg, "--separate-callers=auto",
 482                             CLG_(clo).separate_callers, CONFIG_AUTO) {}
 483    else if VG_INT_CLO( arg, "--separate-callers",
 484                             CLG_(clo).separate_callers) {}
 485
 486    else if VG_STREQN(10, arg, "--fn-group") {
 487        fn_config* fnc;
 488        HChar* s;
 489        UInt n = VG_(strtoll10)(arg+10, &s);
 490        if ((n <= 0) || *s != '=') return False;
 491        fnc = get_fnc(s+1);
 492        fnc->group = n;
 493    }
 494
 495    else if VG_STREQN(18, arg, "--separate-callers") {
 496        fn_config* fnc;
 497        HChar* s;
 498        UInt n = VG_(strtoll10)(arg+18, &s);
 499        if ((n <= 0) || *s != '=') return False;
 500        fnc = get_fnc(s+1);
 501        fnc->separate_callers = n;
 502    }
 503
 504    else if VG_STREQN(15, arg, "--separate-recs") {
 505        fn_config* fnc;
 506        HChar* s;
 507        UInt n = VG_(strtoll10)(arg+15, &s);
 508        if ((n <= 0) || *s != '=') return False;
 509        fnc = get_fnc(s+1);
 510        fnc->separate_recursions = n;
 511    }
 512
 513    else if VG_STR_CLO(arg, "--callgrind-out-file", CLG_(clo).out_format) {}
 514
 515    else if VG_BOOL_CLO(arg, "--mangle-names", CLG_(clo).mangle_names) {}
 516
 517    else if VG_BOOL_CLO(arg, "--skip-direct-rec",
 518                             CLG_(clo).skip_direct_recursion) {}
 519
 520    else if VG_BOOL_CLO(arg, "--dump-bbs",   CLG_(clo).dump_bbs) {}
 521    else if VG_BOOL_CLO(arg, "--dump-line",  CLG_(clo).dump_line) {}
 522    else if VG_BOOL_CLO(arg, "--dump-instr", CLG_(clo).dump_instr) {}
 523    else if VG_BOOL_CLO(arg, "--dump-bb",    CLG_(clo).dump_bb) {}
 524
 525    else if VG_INT_CLO( arg, "--dump-every-bb", CLG_(clo).dump_every_bb) {}
 526
 527    else if VG_BOOL_CLO(arg, "--collect-alloc",   CLG_(clo).collect_alloc) {}
 528    else if VG_BOOL_CLO(arg, "--collect-systime", CLG_(clo).collect_systime) {}
 529    else if VG_BOOL_CLO(arg, "--collect-bus",     CLG_(clo).collect_bus) {}
 530    /* for option compatibility with cachegrind */
 531    else if VG_BOOL_CLO(arg, "--cache-sim",       CLG_(clo).simulate_cache) {}
 532    /* compatibility alias, deprecated option */
 533    else if VG_BOOL_CLO(arg, "--simulate-cache",  CLG_(clo).simulate_cache) {}
 534    /* for option compatibility with cachegrind */
 535    else if VG_BOOL_CLO(arg, "--branch-sim",      CLG_(clo).simulate_branch) {}
 536    else {
 537        Bool isCachesimOption = (*CLG_(cachesim).parse_opt)(arg);
 538
 539        /* cache simulator is used if a simulator option is given */
 540        if (isCachesimOption)
 541            CLG_(clo).simulate_cache = True;
 542
 543        return isCachesimOption;
 544    }
 545
 546    return True;
 547 }
 548
 549 void CLG_(print_usage)(void)
 550 {
 551    VG_(printf)(
 552 "\n   dump creation options:\n"
 553 "    --callgrind-out-file=<f>  Output file name [callgrind.out.%%p]\n"
 554 "    --dump-line=no|yes        Dump source lines of costs? [yes]\n"
 555 "    --dump-instr=no|yes       Dump instruction address of costs? [no]\n"
 556 "    --compress-strings=no|yes Compress strings in profile dump? [yes]\n"
 557 "    --compress-pos=no|yes     Compress positions in profile dump? [yes]\n"
 558 "    --combine-dumps=no|yes    Concat all dumps into same file [no]\n"
 559 #if CLG_EXPERIMENTAL
 560 "    --compress-events=no|yes  Compress events in profile dump? [no]\n"
 561 "    --dump-bb=no|yes          Dump basic block address of costs? [no]\n"
 562 "    --dump-bbs=no|yes         Dump basic block info? [no]\n"
 563 "    --dump-skipped=no|yes     Dump info on skipped functions in calls? [no]\n"
 564 "    --mangle-names=no|yes     Mangle separation into names? [yes]\n"
 565 #endif
 566
 567 "\n   activity options (for interactivity use callgrind_control):\n"
 568 "    --dump-every-bb=<count>   Dump every <count> basic blocks [0=never]\n"
 569 "    --dump-before=<func>      Dump when entering function\n"
 570 "    --zero-before=<func>      Zero all costs when entering function\n"
 571 "    --dump-after=<func>       Dump when leaving function\n"
 572 #if CLG_EXPERIMENTAL
 573 "    --dump-objs=no|yes        Dump static object information [no]\n"
 574 #endif
 575
 576 "\n   data collection options:\n"
 577 "    --instr-atstart=no|yes    Do instrumentation at callgrind start [yes]\n"
 578 "    --collect-atstart=no|yes  Collect at process/thread start [yes]\n"
 579 "    --toggle-collect=<func>   Toggle collection on enter/leave function\n"
 580 "    --collect-jumps=no|yes    Collect jumps? [no]\n"
 581 "    --collect-bus=no|yes      Collect global bus events? [no]\n"
 582 #if CLG_EXPERIMENTAL
 583 "    --collect-alloc=no|yes    Collect memory allocation info? [no]\n"
 584 #endif
 585 "    --collect-systime=no|yes  Collect system call time info? [no]\n"
 586
 587 "\n   cost entity separation options:\n"
 588 "    --separate-threads=no|yes Separate data per thread [no]\n"
 589 "    --separate-callers=<n>    Separate functions by call chain length [0]\n"
 590 "    --separate-callers<n>=<f> Separate <n> callers for function <f>\n"
 591 "    --separate-recs=<n>       Separate function recursions up to level [2]\n"
 592 "    --separate-recs<n>=<f>    Separate <n> recursions for function <f>\n"
 593 "    --skip-plt=no|yes         Ignore calls to/from PLT sections? [yes]\n"
 594 "    --skip-direct-rec=no|yes  Ignore direct recursions? [yes]\n"
 595 "    --fn-skip=<function>      Ignore calls to/from function?\n"
 596 #if CLG_EXPERIMENTAL
 597 "    --fn-group<no>=<func>     Put function into separation group <no>\n"
 598 #endif
 599 "\n   simulation options:\n"
 600 "    --branch-sim=no|yes       Do branch prediction simulation [no]\n"
 601 "    --cache-sim=no|yes        Do cache simulation [no]\n"
 602     );
 603
 604    (*CLG_(cachesim).print_opts)();
 605
 606 //   VG_(printf)("\n"
 607 //             "  For full callgrind documentation, see\n"
 608 //             "  "VG_PREFIX"/share/doc/callgrind/html/callgrind.html\n\n");
 609 }
 610
 611 void CLG_(print_debug_usage)(void)
 612 {
 613     VG_(printf)(
 614
 615 #if CLG_ENABLE_DEBUG
 616 "    --ct-verbose=<level>       Verbosity of standard debug output [0]\n"
 617 "    --ct-vstart=<BB number>    Only be verbose after basic block [0]\n"
 618 "    --ct-verbose<level>=<func> Verbosity while in <func>\n"
 619 #else
 620 "    (none)\n"
 621 #endif
 622
 623     );
 624 }
 625
 626
 627 void CLG_(set_clo_defaults)(void)
 628 {
 629   /* Default values for command line arguments */
 630
 631   /* dump options */
 632   CLG_(clo).out_format       = 0;
 633   CLG_(clo).combine_dumps    = False;
 634   CLG_(clo).compress_strings = True;
 635   CLG_(clo).compress_mangled = False;
 636   CLG_(clo).compress_events  = False;
 637   CLG_(clo).compress_pos     = True;
 638   CLG_(clo).mangle_names     = True;
 639   CLG_(clo).dump_line        = True;
 640   CLG_(clo).dump_instr       = False;
 641   CLG_(clo).dump_bb          = False;
 642   CLG_(clo).dump_bbs         = False;
 643
 644   CLG_(clo).dump_every_bb    = 0;
 645
 646   /* Collection */
 647   CLG_(clo).separate_threads = False;
 648   CLG_(clo).collect_atstart  = True;
 649   CLG_(clo).collect_jumps    = False;
 650   CLG_(clo).collect_alloc    = False;
 651   CLG_(clo).collect_systime  = False;
 652   CLG_(clo).collect_bus      = False;
 653
 654   CLG_(clo).skip_plt         = True;
 655   CLG_(clo).separate_callers = 0;
 656   CLG_(clo).separate_recursions = 2;
 657   CLG_(clo).skip_direct_recursion = False;
 658
 659   /* Instrumentation */
 660   CLG_(clo).instrument_atstart = True;
 661   CLG_(clo).simulate_cache = False;
 662   CLG_(clo).simulate_branch = False;
 663
 664   /* Call graph */
 665   CLG_(clo).pop_on_jump = False;
 666
 667 #if CLG_ENABLE_DEBUG
 668   CLG_(clo).verbose = 0;
 669   CLG_(clo).verbose_start = 0;
 670 #endif
 671 }