Home | History | Annotate | Download | only in callgrind
      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-2015, Josef Weidendorfer (Josef.Weidendorfer (at) 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 existance 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   if (pDebugInfo) {
    438       *pDebugInfo = VG_(find_DebugInfo)(instr_addr);
    439 
    440       // for generated code in anonymous space, pSegInfo is 0
    441    }
    442 
    443    found_file_line = VG_(get_filename_linenum)(instr_addr,
    444 					       file,
    445 					       dir,
    446 					       &line);
    447    found_fn = VG_(get_fnname)(instr_addr, fn_name);
    448 
    449    if (!found_file_line && !found_fn) {
    450      CLG_(stat).no_debug_BBs++;
    451      *file = "???";
    452      *fn_name = "???";
    453      if (line_num) *line_num=0;
    454      result = False;
    455 
    456    } else if ( found_file_line &&  found_fn) {
    457      CLG_(stat).full_debug_BBs++;
    458      if (line_num) *line_num=line;
    459 
    460    } else if ( found_file_line && !found_fn) {
    461      CLG_(stat).file_line_debug_BBs++;
    462      *fn_name = "???";
    463      if (line_num) *line_num=line;
    464 
    465    } else  /*(!found_file_line &&  found_fn)*/ {
    466      CLG_(stat).fn_name_debug_BBs++;
    467      *file = "???";
    468      if (line_num) *line_num=0;
    469    }
    470 
    471    CLG_DEBUG(6, "  - get_debug_info(%#lx): seg '%s', fn %s\n",
    472 	    instr_addr,
    473 	    !pDebugInfo   ? "-" :
    474 	    (*pDebugInfo) ? VG_(DebugInfo_get_filename)(*pDebugInfo) :
    475 	    "(None)",
    476 	    *fn_name);
    477 
    478   return result;
    479 }
    480 
    481 /* for _libc_freeres_wrapper => _exit renaming */
    482 static BB* exit_bb = 0;
    483 
    484 
    485 /*
    486  * Attach function struct to a BB from debug info.
    487  */
    488 fn_node* CLG_(get_fn_node)(BB* bb)
    489 {
    490     const HChar *fnname, *filename, *dirname;
    491     DebugInfo* di;
    492     UInt       line_num;
    493     fn_node*   fn;
    494 
    495     /* fn from debug info is idempotent for a BB */
    496     if (bb->fn) return bb->fn;
    497 
    498     CLG_DEBUG(3,"+ get_fn_node(BB %#lx)\n", bb_addr(bb));
    499 
    500     /* get function/file name, line number and object of
    501      * the BB according to debug information
    502      */
    503     CLG_(get_debug_info)(bb_addr(bb),
    504                          &dirname, &filename, &fnname, &line_num, &di);
    505 
    506     if (0 == VG_(strcmp)(fnname, "???")) {
    507 	int p;
    508         static HChar buf[32];  // for sure large enough
    509 	/* Use address as found in library */
    510 	if (sizeof(Addr) == 4)
    511           p = VG_(sprintf)(buf, "%#08lx", (UWord)bb->offset);
    512 	else
    513 	    // 64bit address
    514           p = VG_(sprintf)(buf, "%#016lx", (UWord)bb->offset);
    515 
    516 	VG_(sprintf)(buf + p, "%s",
    517 		     (bb->sect_kind == Vg_SectData) ? " [Data]" :
    518 		     (bb->sect_kind == Vg_SectBSS)  ? " [BSS]"  :
    519 		     (bb->sect_kind == Vg_SectGOT)  ? " [GOT]"  :
    520 		     (bb->sect_kind == Vg_SectPLT)  ? " [PLT]"  : "");
    521         fnname = buf;
    522     }
    523     else {
    524       if (VG_(get_fnname_if_entry)(bb_addr(bb), &fnname))
    525 	bb->is_entry = 1;
    526     }
    527 
    528     /* HACK for correct _exit:
    529      * _exit is redirected to VG_(__libc_freeres_wrapper) by valgrind,
    530      * so we rename it back again :-)
    531      */
    532     if (0 == VG_(strcmp)(fnname, "vgPlain___libc_freeres_wrapper")
    533 	&& exit_bb) {
    534       CLG_(get_debug_info)(bb_addr(exit_bb),
    535                            &dirname, &filename, &fnname, &line_num, &di);
    536 
    537 	CLG_DEBUG(1, "__libc_freeres_wrapper renamed to _exit\n");
    538     }
    539     if (0 == VG_(strcmp)(fnname, "_exit") && !exit_bb)
    540 	exit_bb = bb;
    541 
    542     if (runtime_resolve_addr &&
    543 	(bb_addr(bb) >= runtime_resolve_addr) &&
    544 	(bb_addr(bb) < runtime_resolve_addr + runtime_resolve_length)) {
    545 	/* BB in runtime_resolve found by code check; use this name */
    546       fnname = "_dl_runtime_resolve";
    547     }
    548 
    549     /* get fn_node struct for this function */
    550     fn = get_fn_node_inseg( di, dirname, filename, fnname);
    551 
    552     /* if this is the 1st time the function is seen,
    553      * some attributes are set */
    554     if (fn->pure_cxt == 0) {
    555 
    556       /* Every function gets a "pure" context, i.e. a context with stack
    557        * depth 1 only with this function. This is for compression of mangled
    558        * names
    559        */
    560       fn_node* pure[2];
    561       pure[0] = 0;
    562       pure[1] = fn;
    563       fn->pure_cxt = CLG_(get_cxt)(pure+1);
    564 
    565       if (bb->sect_kind == Vg_SectPLT)
    566 	fn->skip = CLG_(clo).skip_plt;
    567 
    568       if (VG_(strcmp)(fn->name, "_dl_runtime_resolve")==0) {
    569 	  fn->pop_on_jump = True;
    570 
    571 	  if (VG_(clo_verbosity) > 1)
    572 	      VG_(message)(Vg_DebugMsg, "Symbol match: found runtime_resolve:"
    573                                         " %s +%#lx=%#lx\n",
    574 		      bb->obj->name + bb->obj->last_slash_pos,
    575                       (UWord)bb->offset, bb_addr(bb));
    576       }
    577 
    578       fn->is_malloc  = (VG_(strcmp)(fn->name, "malloc")==0);
    579       fn->is_realloc = (VG_(strcmp)(fn->name, "realloc")==0);
    580       fn->is_free    = (VG_(strcmp)(fn->name, "free")==0);
    581 
    582       /* apply config options from function name patterns
    583        * given on command line */
    584       CLG_(update_fn_config)(fn);
    585     }
    586 
    587 
    588     bb->fn   = fn;
    589     bb->line = line_num;
    590 
    591     if (dirname[0]) {
    592        CLG_DEBUG(3,"- get_fn_node(BB %#lx): %s (in %s:%u)\n",
    593                  bb_addr(bb), fnname, filename, line_num);
    594     } else
    595        CLG_DEBUG(3,"- get_fn_node(BB %#lx): %s (in %s/%s:%u)\n",
    596                  bb_addr(bb), fnname, dirname, filename, line_num);
    597 
    598     return fn;
    599 }
    600 
    601 
    602 /*------------------------------------------------------------*/
    603 /*--- Active function array operations                     ---*/
    604 /*------------------------------------------------------------*/
    605 
    606 /* The active function array is a thread-specific array
    607  * of UInts, mapping function numbers to the active count of
    608  * functions.
    609  * The active count is the number of times a function appears
    610  * in the current call stack, and is used when costs for recursion
    611  * levels should be separated.
    612  */
    613 
    614 UInt* CLG_(get_fn_entry)(Int n)
    615 {
    616   CLG_ASSERT(n < current_fn_active.size);
    617   return current_fn_active.array + n;
    618 }
    619 
    620 void CLG_(init_fn_array)(fn_array* a)
    621 {
    622   Int i;
    623 
    624   CLG_ASSERT(a != 0);
    625 
    626   a->size = N_INITIAL_FN_ARRAY_SIZE;
    627   if (a->size <= CLG_(stat).distinct_fns)
    628     a->size = CLG_(stat).distinct_fns+1;
    629 
    630   a->array = (UInt*) CLG_MALLOC("cl.fn.gfe.1",
    631                                 a->size * sizeof(UInt));
    632   for(i=0;i<a->size;i++)
    633     a->array[i] = 0;
    634 }
    635 
    636 void CLG_(copy_current_fn_array)(fn_array* dst)
    637 {
    638   CLG_ASSERT(dst != 0);
    639 
    640   dst->size  = current_fn_active.size;
    641   dst->array = current_fn_active.array;
    642 }
    643 
    644 fn_array* CLG_(get_current_fn_array)()
    645 {
    646   return &current_fn_active;
    647 }
    648 
    649 void CLG_(set_current_fn_array)(fn_array* a)
    650 {
    651   CLG_ASSERT(a != 0);
    652 
    653   current_fn_active.size  = a->size;
    654   current_fn_active.array = a->array;
    655   if (current_fn_active.size <= CLG_(stat).distinct_fns)
    656     resize_fn_array();
    657 }
    658 
    659 /* ensure that active_array is big enough:
    660  *  <distinct_fns> is the highest index, so <fn_active_array_size>
    661  *  has to be bigger than that.
    662  */
    663 static void resize_fn_array(void)
    664 {
    665     UInt* new_array;
    666     Int i;
    667 
    668     UInt newsize = current_fn_active.size;
    669     while (newsize <= CLG_(stat).distinct_fns) newsize *=2;
    670 
    671     CLG_DEBUG(0, "Resize fn_active_array: %u => %u\n",
    672 	     current_fn_active.size, newsize);
    673 
    674     new_array = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
    675     for(i=0;i<current_fn_active.size;i++)
    676       new_array[i] = current_fn_active.array[i];
    677     while(i<newsize)
    678 	new_array[i++] = 0;
    679 
    680     VG_(free)(current_fn_active.array);
    681     current_fn_active.size = newsize;
    682     current_fn_active.array = new_array;
    683     CLG_(stat).fn_array_resizes++;
    684 }
    685 
    686 
    687