callgrind/fn.c

   1 /*--------------------------------------------------------------------*/
   2 /*--- Callgrind                                                    ---*/
   3 /*---                                                      ct_fn.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Callgrind, a Valgrind tool for call tracing.
   8
   9    Copyright (C) 2002-2017, Josef Weidendorfer (Josef.Weidendorfer@gmx.de)
  10
  11    This program is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU General Public License as
  13    published by the Free Software Foundation; either version 2 of the
  14    License, or (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful, but
  17    WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  24    02111-1307, USA.
  25
  26    The GNU General Public License is contained in the file COPYING.
  27 */
  28
  29 #include "global.h"
  30
  31 #define N_INITIAL_FN_ARRAY_SIZE 10071
  32
  33 static fn_array current_fn_active;
  34
  35 static Addr runtime_resolve_addr = 0;
  36 static int  runtime_resolve_length = 0;
  37
  38 // a code pattern is a list of tuples (start offset, length)
  39 struct chunk_t { int start, len; };
  40 struct pattern
  41 {
  42     const HChar* name;
  43     int len;
  44     struct chunk_t chunk[];
  45 };
  46
  47 /* Scan for a pattern in the code of an ELF object.
  48  * If found, return true and set runtime_resolve_{addr,length}
  49  */
  50 __attribute__((unused))    // Possibly;  depends on the platform.
  51 static Bool check_code(obj_node* obj,
  52                        UChar code[], struct pattern* pat)
  53 {
  54     Bool found;
  55     Addr addr, end;
  56     int chunk, start, len;
  57
  58     /* first chunk of pattern should always start at offset 0 and
  59      * have at least 3 bytes */
  60     CLG_ASSERT((pat->chunk[0].start == 0) && (pat->chunk[0].len >2));
  61
  62     CLG_DEBUG(1, "check_code: %s, pattern %s, check %d bytes of [%x %x %x...]\n",
  63               obj->name, pat->name, pat->chunk[0].len, code[0], code[1], code[2]);
  64
  65     end = obj->start + obj->size - pat->len;
  66     addr = obj->start;
  67     while(addr < end) {
  68         found = (VG_(memcmp)( (void*)addr, code, pat->chunk[0].len) == 0);
  69
  70         if (found) {
  71             chunk = 1;
  72             while(1) {
  73                 start = pat->chunk[chunk].start;
  74                 len   = pat->chunk[chunk].len;
  75                 if (len == 0) break;
  76
  77                 CLG_ASSERT(len >2);
  78                 CLG_DEBUG(1, " found chunk %d at %#lx, checking %d bytes "
  79                              "of [%x %x %x...]\n",
  80                           chunk-1, addr - obj->start, len,
  81                           code[start], code[start+1], code[start+2]);
  82
  83                 if (VG_(memcmp)( (void*)(addr+start), code+start, len) != 0) {
  84                     found = False;
  85                     break;
  86                 }
  87                 chunk++;
  88             }
  89
  90             if (found) {
  91                 CLG_DEBUG(1, "found at offset %#lx.\n", addr - obj->start);
  92                 if (VG_(clo_verbosity) > 1)
  93                     VG_(message)(Vg_DebugMsg, "Found runtime_resolve (%s): "
  94                                               "%s +%#lx=%#lx, length %d\n",
  95                                  pat->name, obj->name + obj->last_slash_pos,
  96                                  addr - obj->start, addr, pat->len);
  97
  98                 runtime_resolve_addr   = addr;
  99                 runtime_resolve_length = pat->len;
 100                 return True;
 101             }
 102         }
 103         addr++;
 104     }
 105     CLG_DEBUG(1, " found nothing.\n");
 106     return False;
 107 }
 108
 109
 110 /* _ld_runtime_resolve, located in ld.so, needs special handling:
 111  * The jump at end into the resolved function should not be
 112  * represented as a call (as usually done in callgrind with jumps),
 113  * but as a return + call. Otherwise, the repeated existence of
 114  * _ld_runtime_resolve in call chains will lead to huge cycles,
 115  * making the profile almost worthless.
 116  *
 117  * If ld.so is stripped, the symbol will not appear. But as this
 118  * function is handcrafted assembler, we search for it.
 119  *
 120  * We stop if the ELF object name does not seem to be the runtime linker
 121  */
 122 static Bool search_runtime_resolve(obj_node* obj)
 123 {
 124 #if defined(VGP_x86_linux)
 125     static UChar code[] = {
 126         /* 0*/ 0x50, 0x51, 0x52, 0x8b, 0x54, 0x24, 0x10, 0x8b,
 127         /* 8*/ 0x44, 0x24, 0x0c, 0xe8, 0x70, 0x01, 0x00, 0x00,
 128         /*16*/ 0x5a, 0x59, 0x87, 0x04, 0x24, 0xc2, 0x08, 0x00 };
 129     /* Check ranges [0-11] and [16-23] ([12-15] is an absolute address) */
 130     static struct pattern pat = {
 131         "x86-def", 24, {{ 0,12 }, { 16,8 }, { 24,0}} };
 132
 133     /* Pattern for glibc-2.8 on OpenSuse11.0 */
 134     static UChar code_28[] = {
 135         /* 0*/ 0x50, 0x51, 0x52, 0x8b, 0x54, 0x24, 0x10, 0x8b,
 136         /* 8*/ 0x44, 0x24, 0x0c, 0xe8, 0x70, 0x01, 0x00, 0x00,
 137         /*16*/ 0x5a, 0x8b, 0x0c, 0x24, 0x89, 0x04, 0x24, 0x8b,
 138         /*24*/ 0x44, 0x24, 0x04, 0xc2, 0x0c, 0x00 };
 139     static struct pattern pat_28 = {
 140         "x86-glibc2.8", 30, {{ 0,12 }, { 16,14 }, { 30,0}} };
 141
 142     if (VG_(strncmp)(obj->name, "/lib/ld", 7) != 0) return False;
 143     if (check_code(obj, code, &pat)) return True;
 144     if (check_code(obj, code_28, &pat_28)) return True;
 145     return False;
 146 #endif
 147
 148 #if defined(VGP_ppc32_linux)
 149     static UChar code[] = {
 150         /* 0*/ 0x94, 0x21, 0xff, 0xc0, 0x90, 0x01, 0x00, 0x0c,
 151         /* 8*/ 0x90, 0x61, 0x00, 0x10, 0x90, 0x81, 0x00, 0x14,
 152         /*16*/ 0x7d, 0x83, 0x63, 0x78, 0x90, 0xa1, 0x00, 0x18,
 153         /*24*/ 0x7d, 0x64, 0x5b, 0x78, 0x90, 0xc1, 0x00, 0x1c,
 154         /*32*/ 0x7c, 0x08, 0x02, 0xa6, 0x90, 0xe1, 0x00, 0x20,
 155         /*40*/ 0x90, 0x01, 0x00, 0x30, 0x91, 0x01, 0x00, 0x24,
 156         /*48*/ 0x7c, 0x00, 0x00, 0x26, 0x91, 0x21, 0x00, 0x28,
 157         /*56*/ 0x91, 0x41, 0x00, 0x2c, 0x90, 0x01, 0x00, 0x08,
 158         /*64*/ 0x48, 0x00, 0x02, 0x91, 0x7c, 0x69, 0x03, 0xa6, /* at 64: bl aff0 <fixup> */
 159         /*72*/ 0x80, 0x01, 0x00, 0x30, 0x81, 0x41, 0x00, 0x2c,
 160         /*80*/ 0x81, 0x21, 0x00, 0x28, 0x7c, 0x08, 0x03, 0xa6,
 161         /*88*/ 0x81, 0x01, 0x00, 0x24, 0x80, 0x01, 0x00, 0x08,
 162         /*96*/ 0x80, 0xe1, 0x00, 0x20, 0x80, 0xc1, 0x00, 0x1c,
 163         /*104*/0x7c, 0x0f, 0xf1, 0x20, 0x80, 0xa1, 0x00, 0x18,
 164         /*112*/0x80, 0x81, 0x00, 0x14, 0x80, 0x61, 0x00, 0x10,
 165         /*120*/0x80, 0x01, 0x00, 0x0c, 0x38, 0x21, 0x00, 0x40,
 166         /*128*/0x4e, 0x80, 0x04, 0x20 };
 167     static struct pattern pat = {
 168         "ppc32-def", 132, {{ 0,65 }, { 68,64 }, { 132,0 }} };
 169
 170     if (VG_(strncmp)(obj->name, "/lib/ld", 7) != 0) return False;
 171     return check_code(obj, code, &pat);
 172 #endif
 173
 174 #if defined(VGP_amd64_linux)
 175     static UChar code[] = {
 176         /* 0*/ 0x48, 0x83, 0xec, 0x38, 0x48, 0x89, 0x04, 0x24,
 177         /* 8*/ 0x48, 0x89, 0x4c, 0x24, 0x08, 0x48, 0x89, 0x54, 0x24, 0x10,
 178         /*18*/ 0x48, 0x89, 0x74, 0x24, 0x18, 0x48, 0x89, 0x7c, 0x24, 0x20,
 179         /*28*/ 0x4c, 0x89, 0x44, 0x24, 0x28, 0x4c, 0x89, 0x4c, 0x24, 0x30,
 180         /*38*/ 0x48, 0x8b, 0x74, 0x24, 0x40, 0x49, 0x89, 0xf3,
 181         /*46*/ 0x4c, 0x01, 0xde, 0x4c, 0x01, 0xde, 0x48, 0xc1, 0xe6, 0x03,
 182         /*56*/ 0x48, 0x8b, 0x7c, 0x24, 0x38, 0xe8, 0xee, 0x01, 0x00, 0x00,
 183         /*66*/ 0x49, 0x89, 0xc3, 0x4c, 0x8b, 0x4c, 0x24, 0x30,
 184         /*74*/ 0x4c, 0x8b, 0x44, 0x24, 0x28, 0x48, 0x8b, 0x7c, 0x24, 0x20,
 185         /*84*/ 0x48, 0x8b, 0x74, 0x24, 0x18, 0x48, 0x8b, 0x54, 0x24, 0x10,
 186         /*94*/ 0x48, 0x8b, 0x4c, 0x24, 0x08, 0x48, 0x8b, 0x04, 0x24,
 187         /*103*/0x48, 0x83, 0xc4, 0x48, 0x41, 0xff, 0xe3 };
 188     static struct pattern pat = {
 189         "amd64-def", 110, {{ 0,62 }, { 66,44 }, { 110,0 }} };
 190
 191     if ((VG_(strncmp)(obj->name, "/lib/ld", 7) != 0) &&
 192         (VG_(strncmp)(obj->name, "/lib64/ld", 9) != 0)) return False;
 193     return check_code(obj, code, &pat);
 194 #endif
 195
 196     /* For other platforms, no patterns known */
 197     return False;
 198 }
 199
 200
 201 /*------------------------------------------------------------*/
 202 /*--- Object/File/Function hash entry operations           ---*/
 203 /*------------------------------------------------------------*/
 204
 205 /* Object hash table, fixed */
 206 static obj_node* obj_table[N_OBJ_ENTRIES];
 207
 208 void CLG_(init_obj_table)()
 209 {
 210     Int i;
 211     for (i = 0; i < N_OBJ_ENTRIES; i++)
 212         obj_table[i] = 0;
 213 }
 214
 215 #define HASH_CONSTANT   256
 216
 217 static UInt str_hash(const HChar *s, UInt table_size)
 218 {
 219     int hash_value = 0;
 220     for ( ; *s; s++)
 221         hash_value = (HASH_CONSTANT * hash_value + *s) % table_size;
 222     return hash_value;
 223 }
 224
 225
 226 static const HChar* anonymous_obj = "???";
 227
 228 static __inline__
 229 obj_node* new_obj_node(DebugInfo* di, obj_node* next)
 230 {
 231    Int i;
 232    obj_node* obj;
 233
 234    obj = (obj_node*) CLG_MALLOC("cl.fn.non.1", sizeof(obj_node));
 235    obj->name  = di ? VG_(strdup)( "cl.fn.non.2",
 236                                   VG_(DebugInfo_get_filename)(di) )
 237                    : anonymous_obj;
 238    for (i = 0; i < N_FILE_ENTRIES; i++) {
 239       obj->files[i] = NULL;
 240    }
 241    CLG_(stat).distinct_objs ++;
 242    obj->number  = CLG_(stat).distinct_objs;
 243    /* JRS 2008 Feb 19: maybe rename .start/.size/.offset to
 244       .text_avma/.text_size/.test_bias to make it clearer what these
 245       fields really mean */
 246    obj->start   = di ? VG_(DebugInfo_get_text_avma)(di) : 0;
 247    obj->size    = di ? VG_(DebugInfo_get_text_size)(di) : 0;
 248    obj->offset  = di ? VG_(DebugInfo_get_text_bias)(di) : 0;
 249    obj->next    = next;
 250
 251    // not only used for debug output (see static.c)
 252    obj->last_slash_pos = 0;
 253    i = 0;
 254    while(obj->name[i]) {
 255         if (obj->name[i]=='/') obj->last_slash_pos = i+1;
 256         i++;
 257    }
 258
 259    if (runtime_resolve_addr == 0) search_runtime_resolve(obj);
 260
 261    return obj;
 262 }
 263
 264 obj_node* CLG_(get_obj_node)(DebugInfo* di)
 265 {
 266     obj_node*    curr_obj_node;
 267     UInt         objname_hash;
 268     const HChar* obj_name;
 269
 270     obj_name = di ? VG_(DebugInfo_get_filename)(di) : anonymous_obj;
 271
 272     /* lookup in obj hash */
 273     objname_hash = str_hash(obj_name, N_OBJ_ENTRIES);
 274     curr_obj_node = obj_table[objname_hash];
 275     while (NULL != curr_obj_node &&
 276            VG_(strcmp)(obj_name, curr_obj_node->name) != 0) {
 277         curr_obj_node = curr_obj_node->next;
 278     }
 279     if (NULL == curr_obj_node) {
 280         obj_table[objname_hash] = curr_obj_node =
 281             new_obj_node(di, obj_table[objname_hash]);
 282     }
 283
 284     return curr_obj_node;
 285 }
 286
 287
 288 static __inline__
 289 file_node* new_file_node(const HChar *filename,
 290                          obj_node* obj, file_node* next)
 291 {
 292   Int i;
 293   file_node* file = (file_node*) CLG_MALLOC("cl.fn.nfn.1",
 294                                            sizeof(file_node));
 295   file->name  = VG_(strdup)("cl.fn.nfn.2", filename);
 296   for (i = 0; i < N_FN_ENTRIES; i++) {
 297     file->fns[i] = NULL;
 298   }
 299   CLG_(stat).distinct_files++;
 300   file->number  = CLG_(stat).distinct_files;
 301   file->obj     = obj;
 302   file->next      = next;
 303   return file;
 304 }
 305
 306
 307 file_node* CLG_(get_file_node)(obj_node* curr_obj_node,
 308                                const HChar *dir, const HChar *file)
 309 {
 310     file_node* curr_file_node;
 311     UInt       filename_hash;
 312
 313     /* Build up an absolute pathname, if there is a directory available */
 314     HChar filename[VG_(strlen)(dir) + 1 + VG_(strlen)(file) + 1];
 315     VG_(strcpy)(filename, dir);
 316     if (filename[0] != '\0') {
 317        VG_(strcat)(filename, "/");
 318     }
 319     VG_(strcat)(filename, file);
 320
 321     /* lookup in file hash */
 322     filename_hash = str_hash(filename, N_FILE_ENTRIES);
 323     curr_file_node = curr_obj_node->files[filename_hash];
 324     while (NULL != curr_file_node &&
 325            VG_(strcmp)(filename, curr_file_node->name) != 0) {
 326         curr_file_node = curr_file_node->next;
 327     }
 328     if (NULL == curr_file_node) {
 329         curr_obj_node->files[filename_hash] = curr_file_node =
 330             new_file_node(filename, curr_obj_node,
 331                           curr_obj_node->files[filename_hash]);
 332     }
 333
 334     return curr_file_node;
 335 }
 336
 337 /* forward decl. */
 338 static void resize_fn_array(void);
 339
 340 static __inline__
 341 fn_node* new_fn_node(const HChar *fnname,
 342                      file_node* file, fn_node* next)
 343 {
 344     fn_node* fn = (fn_node*) CLG_MALLOC("cl.fn.nfnnd.1",
 345                                          sizeof(fn_node));
 346     fn->name = VG_(strdup)("cl.fn.nfnnd.2", fnname);
 347
 348     CLG_(stat).distinct_fns++;
 349     fn->number   = CLG_(stat).distinct_fns;
 350     fn->last_cxt = 0;
 351     fn->pure_cxt = 0;
 352     fn->file     = file;
 353     fn->next     = next;
 354
 355     fn->dump_before  = False;
 356     fn->dump_after   = False;
 357     fn->zero_before  = False;
 358     fn->toggle_collect = False;
 359     fn->skip         = False;
 360     fn->pop_on_jump  = CLG_(clo).pop_on_jump;
 361     fn->is_malloc    = False;
 362     fn->is_realloc   = False;
 363     fn->is_free      = False;
 364
 365     fn->group        = 0;
 366     fn->separate_callers    = CLG_(clo).separate_callers;
 367     fn->separate_recursions = CLG_(clo).separate_recursions;
 368
 369 #if CLG_ENABLE_DEBUG
 370     fn->verbosity    = -1;
 371 #endif
 372
 373     if (CLG_(stat).distinct_fns >= current_fn_active.size)
 374         resize_fn_array();
 375
 376     return fn;
 377 }
 378
 379
 380 /* Get a function node in hash2 with known file node.
 381  * hash nodes are created if needed
 382  */
 383 static
 384 fn_node* get_fn_node_infile(file_node* curr_file_node,
 385                             const HChar *fnname)
 386 {
 387     fn_node* curr_fn_node;
 388     UInt     fnname_hash;
 389
 390     CLG_ASSERT(curr_file_node != 0);
 391
 392     /* lookup in function hash */
 393     fnname_hash = str_hash(fnname, N_FN_ENTRIES);
 394     curr_fn_node = curr_file_node->fns[fnname_hash];
 395     while (NULL != curr_fn_node &&
 396            VG_(strcmp)(fnname, curr_fn_node->name) != 0) {
 397         curr_fn_node = curr_fn_node->next;
 398     }
 399     if (NULL == curr_fn_node) {
 400         curr_file_node->fns[fnname_hash] = curr_fn_node =
 401             new_fn_node(fnname, curr_file_node,
 402                         curr_file_node->fns[fnname_hash]);
 403     }
 404
 405     return curr_fn_node;
 406 }
 407
 408
 409 /* Get a function node in a Segment.
 410  * Hash nodes are created if needed.
 411  */
 412 static __inline__
 413 fn_node* get_fn_node_inseg(DebugInfo* di,
 414                            const HChar *dirname,
 415                            const HChar *filename,
 416                            const HChar *fnname)
 417 {
 418   obj_node  *obj  = CLG_(get_obj_node)(di);
 419   file_node *file = CLG_(get_file_node)(obj, dirname, filename);
 420   fn_node   *fn   = get_fn_node_infile(file, fnname);
 421
 422   return fn;
 423 }
 424
 425
 426 Bool CLG_(get_debug_info)(Addr instr_addr,
 427                           const HChar **dir,
 428                           const HChar **file,
 429                           const HChar **fn_name, UInt* line_num,
 430                           DebugInfo** pDebugInfo)
 431 {
 432   Bool found_file_line, found_fn, result = True;
 433   UInt line;
 434
 435   CLG_DEBUG(6, "  + get_debug_info(%#lx)\n", instr_addr);
 436
 437   DiEpoch ep = VG_(current_DiEpoch)();
 438   if (pDebugInfo) {
 439       *pDebugInfo = VG_(find_DebugInfo)(ep, instr_addr);
 440
 441       // for generated code in anonymous space, pSegInfo is 0
 442    }
 443
 444    found_file_line = VG_(get_filename_linenum)(ep, instr_addr,
 445                                                file,
 446                                                dir,
 447                                                &line);
 448    found_fn = VG_(get_fnname)(ep, instr_addr, fn_name);
 449
 450    if (!found_file_line && !found_fn) {
 451      CLG_(stat).no_debug_BBs++;
 452      *file = "???";
 453      *fn_name = "???";
 454      if (line_num) *line_num=0;
 455      result = False;
 456
 457    } else if ( found_file_line &&  found_fn) {
 458      CLG_(stat).full_debug_BBs++;
 459      if (line_num) *line_num=line;
 460
 461    } else if ( found_file_line && !found_fn) {
 462      CLG_(stat).file_line_debug_BBs++;
 463      *fn_name = "???";
 464      if (line_num) *line_num=line;
 465
 466    } else  /*(!found_file_line &&  found_fn)*/ {
 467      CLG_(stat).fn_name_debug_BBs++;
 468      *file = "???";
 469      if (line_num) *line_num=0;
 470    }
 471
 472    CLG_DEBUG(6, "  - get_debug_info(%#lx): seg '%s', fn %s\n",
 473             instr_addr,
 474             !pDebugInfo   ? "-" :
 475             (*pDebugInfo) ? VG_(DebugInfo_get_filename)(*pDebugInfo) :
 476             "(None)",
 477             *fn_name);
 478
 479   return result;
 480 }
 481
 482 /* for _libc_freeres_wrapper => _exit renaming */
 483 static BB* exit_bb = 0;
 484
 485
 486 /*
 487  * Attach function struct to a BB from debug info.
 488  */
 489 fn_node* CLG_(get_fn_node)(BB* bb)
 490 {
 491     const HChar *fnname, *filename, *dirname;
 492     DebugInfo* di;
 493     UInt       line_num;
 494     fn_node*   fn;
 495
 496     /* fn from debug info is idempotent for a BB */
 497     if (bb->fn) return bb->fn;
 498
 499     CLG_DEBUG(3,"+ get_fn_node(BB %#lx)\n", bb_addr(bb));
 500
 501     /* get function/file name, line number and object of
 502      * the BB according to debug information
 503      */
 504     CLG_(get_debug_info)(bb_addr(bb),
 505                          &dirname, &filename, &fnname, &line_num, &di);
 506
 507     DiEpoch ep = VG_(current_DiEpoch)();
 508     if (0 == VG_(strcmp)(fnname, "???")) {
 509         int p;
 510         static HChar buf[32];  // for sure large enough
 511         /* Use address as found in library */
 512         if (sizeof(Addr) == 4)
 513           p = VG_(sprintf)(buf, "%#08lx", (UWord)bb->offset);
 514         else
 515             // 64bit address
 516           p = VG_(sprintf)(buf, "%#016lx", (UWord)bb->offset);
 517
 518         VG_(sprintf)(buf + p, "%s",
 519                      (bb->sect_kind == Vg_SectData) ? " [Data]" :
 520                      (bb->sect_kind == Vg_SectBSS)  ? " [BSS]"  :
 521                      (bb->sect_kind == Vg_SectGOT)  ? " [GOT]"  :
 522                      (bb->sect_kind == Vg_SectPLT)  ? " [PLT]"  : "");
 523         fnname = buf;
 524     }
 525     else {
 526       if (VG_(get_fnname_if_entry)(ep, bb_addr(bb), &fnname))
 527         bb->is_entry = 1;
 528     }
 529
 530     /* HACK for correct _exit:
 531      * _exit is redirected to VG_(__libc_freeres_wrapper) by valgrind,
 532      * so we rename it back again :-)
 533      */
 534     if (0 == VG_(strcmp)(fnname, "vgPlain___libc_freeres_wrapper")
 535         && exit_bb) {
 536       CLG_(get_debug_info)(bb_addr(exit_bb),
 537                            &dirname, &filename, &fnname, &line_num, &di);
 538
 539         CLG_DEBUG(1, "__libc_freeres_wrapper renamed to _exit\n");
 540     }
 541     if (0 == VG_(strcmp)(fnname, "_exit") && !exit_bb)
 542         exit_bb = bb;
 543
 544     if (runtime_resolve_addr &&
 545         (bb_addr(bb) >= runtime_resolve_addr) &&
 546         (bb_addr(bb) < runtime_resolve_addr + runtime_resolve_length)) {
 547         /* BB in runtime_resolve found by code check; use this name */
 548       fnname = "_dl_runtime_resolve";
 549     }
 550
 551     /* get fn_node struct for this function */
 552     fn = get_fn_node_inseg( di, dirname, filename, fnname);
 553
 554     /* if this is the 1st time the function is seen,
 555      * some attributes are set */
 556     if (fn->pure_cxt == 0) {
 557
 558       /* Every function gets a "pure" context, i.e. a context with stack
 559        * depth 1 only with this function. This is for compression of mangled
 560        * names
 561        */
 562       fn_node* pure[2];
 563       pure[0] = 0;
 564       pure[1] = fn;
 565       fn->pure_cxt = CLG_(get_cxt)(pure+1);
 566
 567       if (bb->sect_kind == Vg_SectPLT)
 568         fn->skip = CLG_(clo).skip_plt;
 569
 570       if (VG_(strcmp)(fn->name, "_dl_runtime_resolve")==0) {
 571           fn->pop_on_jump = True;
 572
 573           if (VG_(clo_verbosity) > 1)
 574               VG_(message)(Vg_DebugMsg, "Symbol match: found runtime_resolve:"
 575                                         " %s +%#lx=%#lx\n",
 576                       bb->obj->name + bb->obj->last_slash_pos,
 577                       (UWord)bb->offset, bb_addr(bb));
 578       }
 579
 580       fn->is_malloc  = (VG_(strcmp)(fn->name, "malloc")==0);
 581       fn->is_realloc = (VG_(strcmp)(fn->name, "realloc")==0);
 582       fn->is_free    = (VG_(strcmp)(fn->name, "free")==0);
 583
 584       /* apply config options from function name patterns
 585        * given on command line */
 586       CLG_(update_fn_config)(fn);
 587     }
 588
 589
 590     bb->fn   = fn;
 591     bb->line = line_num;
 592
 593     if (dirname[0]) {
 594        CLG_DEBUG(3,"- get_fn_node(BB %#lx): %s (in %s:%u)\n",
 595                  bb_addr(bb), fnname, filename, line_num);
 596     } else
 597        CLG_DEBUG(3,"- get_fn_node(BB %#lx): %s (in %s/%s:%u)\n",
 598                  bb_addr(bb), fnname, dirname, filename, line_num);
 599
 600     return fn;
 601 }
 602
 603
 604 /*------------------------------------------------------------*/
 605 /*--- Active function array operations                     ---*/
 606 /*------------------------------------------------------------*/
 607
 608 /* The active function array is a thread-specific array
 609  * of UInts, mapping function numbers to the active count of
 610  * functions.
 611  * The active count is the number of times a function appears
 612  * in the current call stack, and is used when costs for recursion
 613  * levels should be separated.
 614  */
 615
 616 UInt* CLG_(get_fn_entry)(Int n)
 617 {
 618   CLG_ASSERT(n < current_fn_active.size);
 619   return current_fn_active.array + n;
 620 }
 621
 622 void CLG_(init_fn_array)(fn_array* a)
 623 {
 624   Int i;
 625
 626   CLG_ASSERT(a != 0);
 627
 628   a->size = N_INITIAL_FN_ARRAY_SIZE;
 629   if (a->size <= CLG_(stat).distinct_fns)
 630     a->size = CLG_(stat).distinct_fns+1;
 631
 632   a->array = (UInt*) CLG_MALLOC("cl.fn.gfe.1",
 633                                 a->size * sizeof(UInt));
 634   for(i=0;i<a->size;i++)
 635     a->array[i] = 0;
 636 }
 637
 638 void CLG_(copy_current_fn_array)(fn_array* dst)
 639 {
 640   CLG_ASSERT(dst != 0);
 641
 642   dst->size  = current_fn_active.size;
 643   dst->array = current_fn_active.array;
 644 }
 645
 646 fn_array* CLG_(get_current_fn_array)()
 647 {
 648   return &current_fn_active;
 649 }
 650
 651 void CLG_(set_current_fn_array)(fn_array* a)
 652 {
 653   CLG_ASSERT(a != 0);
 654
 655   current_fn_active.size  = a->size;
 656   current_fn_active.array = a->array;
 657   if (current_fn_active.size <= CLG_(stat).distinct_fns)
 658     resize_fn_array();
 659 }
 660
 661 /* ensure that active_array is big enough:
 662  *  <distinct_fns> is the highest index, so <fn_active_array_size>
 663  *  has to be bigger than that.
 664  */
 665 static void resize_fn_array(void)
 666 {
 667     UInt* new_array;
 668     Int i;
 669
 670     UInt newsize = current_fn_active.size;
 671     while (newsize <= CLG_(stat).distinct_fns) newsize *=2;
 672
 673     CLG_DEBUG(0, "Resize fn_active_array: %u => %u\n",
 674              current_fn_active.size, newsize);
 675
 676     new_array = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
 677     for(i=0;i<current_fn_active.size;i++)
 678       new_array[i] = current_fn_active.array[i];
 679     while(i<newsize)
 680         new_array[i++] = 0;
 681
 682     VG_(free)(current_fn_active.array);
 683     current_fn_active.size = newsize;
 684     current_fn_active.array = new_array;
 685     CLG_(stat).fn_array_resizes++;
 686 }
 687
 688