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 (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 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 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 ¤t_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
