1 /* 2 This file is part of Callgrind, a Valgrind tool for call graph 3 profiling programs. 4 5 Copyright (C) 2002-2017, Josef Weidendorfer (Josef.Weidendorfer (at) gmx.de) 6 7 This tool is derived from and contains lot of code from Cachegrind 8 Copyright (C) 2002-2017 Nicholas Nethercote (njn (at) 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 "global.h" 29 #include "events.h" 30 31 /* If debugging mode of, dummy functions are provided (see below) 32 */ 33 #if CLG_ENABLE_DEBUG 34 35 /*------------------------------------------------------------*/ 36 /*--- Debug output helpers ---*/ 37 /*------------------------------------------------------------*/ 38 39 static void print_indent(int s) 40 { 41 /* max of 40 spaces */ 42 const HChar sp[] = " "; 43 if (s>40) s=40; 44 VG_(printf)("%s", sp+40-s); 45 } 46 47 void CLG_(print_bb)(int s, BB* bb) 48 { 49 if (s<0) { 50 s = -s; 51 print_indent(s); 52 } 53 54 VG_(printf)("BB %#lx (Obj '%s')", bb_addr(bb), bb->obj->name); 55 } 56 57 static 58 void print_mangled_cxt(Context* cxt, int rec_index) 59 { 60 int i; 61 62 if (!cxt) 63 VG_(printf)("(none)"); 64 else { 65 VG_(printf)("%s", cxt->fn[0]->name); 66 if (rec_index >0) 67 VG_(printf)("'%d", rec_index +1); 68 for(i=1;i<cxt->size;i++) 69 VG_(printf)("'%s", cxt->fn[i]->name); 70 } 71 } 72 73 74 75 void CLG_(print_cxt)(Int s, Context* cxt, int rec_index) 76 { 77 if (s<0) { 78 s = -s; 79 print_indent(s); 80 } 81 82 if (cxt) { 83 UInt *pactive = CLG_(get_fn_entry)(cxt->fn[0]->number); 84 CLG_ASSERT(rec_index < cxt->fn[0]->separate_recursions); 85 86 VG_(printf)("Cxt %u" ,cxt->base_number + rec_index); 87 if (*pactive>0) 88 VG_(printf)(" [active=%u]", *pactive); 89 VG_(printf)(": "); 90 print_mangled_cxt(cxt, rec_index); 91 VG_(printf)("\n"); 92 } 93 else 94 VG_(printf)("(no context)\n"); 95 } 96 97 void CLG_(print_execstate)(int s, exec_state* es) 98 { 99 if (s<0) { 100 s = -s; 101 print_indent(s); 102 } 103 104 if (!es) { 105 VG_(printf)("ExecState 0x0\n"); 106 return; 107 } 108 109 VG_(printf)("ExecState [Sig %d, collect %s, nonskipped %p]: jmps_passed %d\n", 110 es->sig, es->collect?"yes":"no", 111 es->nonskipped, es->jmps_passed); 112 } 113 114 115 void CLG_(print_bbcc)(int s, BBCC* bbcc) 116 { 117 BB* bb; 118 119 if (s<0) { 120 s = -s; 121 print_indent(s); 122 } 123 124 if (!bbcc) { 125 VG_(printf)("BBCC 0x0\n"); 126 return; 127 } 128 129 bb = bbcc->bb; 130 CLG_ASSERT(bb!=0); 131 132 VG_(printf)("%s +%#lx=%#lx, ", 133 bb->obj->name + bb->obj->last_slash_pos, 134 (UWord)bb->offset, bb_addr(bb)); 135 CLG_(print_cxt)(s+8, bbcc->cxt, bbcc->rec_index); 136 } 137 138 void CLG_(print_eventset)(int s, EventSet* es) 139 { 140 int i, j; 141 UInt mask; 142 EventGroup* eg; 143 144 if (s<0) { 145 s = -s; 146 print_indent(s); 147 } 148 149 if (!es) { 150 VG_(printf)("(EventSet not set)\n"); 151 return; 152 } 153 154 VG_(printf)("EventSet %u (%d groups, size %d):", 155 es->mask, es->count, es->size); 156 157 if (es->count == 0) { 158 VG_(printf)("-\n"); 159 return; 160 } 161 162 for(i=0, mask=1; i<MAX_EVENTGROUP_COUNT; i++, mask=mask<<1) { 163 if ((es->mask & mask)==0) continue; 164 eg = CLG_(get_event_group)(i); 165 if (!eg) continue; 166 VG_(printf)(" (%d: %s", i, eg->name[0]); 167 for(j=1; j<eg->size; j++) 168 VG_(printf)(" %s", eg->name[j]); 169 VG_(printf)(")"); 170 } 171 VG_(printf)("\n"); 172 } 173 174 175 void CLG_(print_cost)(int s, EventSet* es, ULong* c) 176 { 177 Int i, j, pos, off; 178 UInt mask; 179 EventGroup* eg; 180 181 if (s<0) { 182 s = -s; 183 print_indent(s); 184 } 185 186 if (!es) { 187 VG_(printf)("Cost (Nothing, EventSet not set)\n"); 188 return; 189 } 190 if (!c) { 191 VG_(printf)("Cost (Null, EventSet %u)\n", es->mask); 192 return; 193 } 194 195 if (es->size == 0) { 196 VG_(printf)("Cost (Nothing, EventSet with len 0)\n"); 197 return; 198 } 199 200 pos = s; 201 pos += VG_(printf)("Cost [%p]: ", c); 202 off = 0; 203 for(i=0, mask=1; i<MAX_EVENTGROUP_COUNT; i++, mask=mask<<1) { 204 if ((es->mask & mask)==0) continue; 205 eg = CLG_(get_event_group)(i); 206 if (!eg) continue; 207 for(j=0; j<eg->size; j++) { 208 209 if (off>0) { 210 if (pos > 70) { 211 VG_(printf)(",\n"); 212 print_indent(s+5); 213 pos = s+5; 214 } 215 else 216 pos += VG_(printf)(", "); 217 } 218 219 pos += VG_(printf)("%s %llu", eg->name[j], c[off++]); 220 } 221 } 222 VG_(printf)("\n"); 223 } 224 225 226 void CLG_(print_short_jcc)(jCC* jcc) 227 { 228 if (jcc) 229 VG_(printf)("%#lx => %#lx [calls %llu/Ir %llu, Dr %llu, Dw %llu]", 230 bb_jmpaddr(jcc->from->bb), 231 bb_addr(jcc->to->bb), 232 jcc->call_counter, 233 jcc->cost ? jcc->cost[fullOffset(EG_IR)]:0, 234 jcc->cost ? jcc->cost[fullOffset(EG_DR)]:0, 235 jcc->cost ? jcc->cost[fullOffset(EG_DW)]:0); 236 else 237 VG_(printf)("[Skipped JCC]"); 238 } 239 240 void CLG_(print_jcc)(int s, jCC* jcc) 241 { 242 if (s<0) { 243 s = -s; 244 print_indent(s); 245 } 246 247 if (!jcc) { 248 VG_(printf)("JCC to skipped function\n"); 249 return; 250 } 251 VG_(printf)("JCC %p from ", jcc); 252 CLG_(print_bbcc)(s+9, jcc->from); 253 print_indent(s+4); 254 VG_(printf)("to "); 255 CLG_(print_bbcc)(s+9, jcc->to); 256 print_indent(s+4); 257 VG_(printf)("Calls %llu\n", jcc->call_counter); 258 print_indent(s+4); 259 CLG_(print_cost)(s+9, CLG_(sets).full, jcc->cost); 260 } 261 262 /* dump out the current call stack */ 263 void CLG_(print_stackentry)(int s, int sp) 264 { 265 call_entry* ce; 266 267 if (s<0) { 268 s = -s; 269 print_indent(s); 270 } 271 272 ce = CLG_(get_call_entry)(sp); 273 VG_(printf)("[%-2d] SP %#lx, RA %#lx", sp, ce->sp, ce->ret_addr); 274 if (ce->nonskipped) 275 VG_(printf)(" NonSkipped BB %#lx / %s", 276 bb_addr(ce->nonskipped->bb), 277 ce->nonskipped->cxt->fn[0]->name); 278 VG_(printf)("\n"); 279 print_indent(s+5); 280 CLG_(print_jcc)(5,ce->jcc); 281 } 282 283 /* debug output */ 284 #if 0 285 static void print_call_stack() 286 { 287 int c; 288 289 VG_(printf)("Call Stack:\n"); 290 for(c=0;c<CLG_(current_call_stack).sp;c++) 291 CLG_(print_stackentry)(-2, c); 292 } 293 #endif 294 295 void CLG_(print_bbcc_fn)(BBCC* bbcc) 296 { 297 obj_node* obj; 298 299 if (!bbcc) { 300 VG_(printf)("%08x", 0u); 301 return; 302 } 303 304 VG_(printf)("%08lx/%c %u:", bb_addr(bbcc->bb), 305 (bbcc->bb->sect_kind == Vg_SectText) ? 'T' : 306 (bbcc->bb->sect_kind == Vg_SectData) ? 'D' : 307 (bbcc->bb->sect_kind == Vg_SectBSS) ? 'B' : 308 (bbcc->bb->sect_kind == Vg_SectGOT) ? 'G' : 309 (bbcc->bb->sect_kind == Vg_SectPLT) ? 'P' : 'U', 310 bbcc->cxt->base_number+bbcc->rec_index); 311 print_mangled_cxt(bbcc->cxt, bbcc->rec_index); 312 313 obj = bbcc->cxt->fn[0]->file->obj; 314 if (obj->name[0]) 315 VG_(printf)(" %s", obj->name+obj->last_slash_pos); 316 317 if (VG_(strcmp)(bbcc->cxt->fn[0]->file->name, "???") !=0) { 318 VG_(printf)(" %s", bbcc->cxt->fn[0]->file->name); 319 if ((bbcc->cxt->fn[0] == bbcc->bb->fn) && (bbcc->bb->line>0)) 320 VG_(printf)(":%u", bbcc->bb->line); 321 } 322 } 323 324 void CLG_(print_bbcc_cost)(int s, BBCC* bbcc) 325 { 326 BB* bb; 327 Int i, cjmpNo; 328 ULong ecounter; 329 330 if (s<0) { 331 s = -s; 332 print_indent(s); 333 } 334 335 if (!bbcc) { 336 VG_(printf)("BBCC 0x0\n"); 337 return; 338 } 339 340 bb = bbcc->bb; 341 CLG_ASSERT(bb!=0); 342 343 CLG_(print_bbcc)(s, bbcc); 344 345 ecounter = bbcc->ecounter_sum; 346 347 print_indent(s+2); 348 VG_(printf)("ECounter: sum %llu ", ecounter); 349 for(i=0; i<bb->cjmp_count; i++) { 350 VG_(printf)("[%u]=%llu ", 351 bb->jmp[i].instr, bbcc->jmp[i].ecounter); 352 } 353 VG_(printf)("\n"); 354 355 cjmpNo = 0; 356 for(i=0; i<bb->instr_count; i++) { 357 InstrInfo* ii = &(bb->instr[i]); 358 print_indent(s+2); 359 VG_(printf)("[%2d] IOff %2u ecnt %3llu ", 360 i, ii->instr_offset, ecounter); 361 CLG_(print_cost)(s+5, ii->eventset, bbcc->cost + ii->cost_offset); 362 363 /* update execution counter */ 364 if (cjmpNo < bb->cjmp_count) 365 if (bb->jmp[cjmpNo].instr == i) { 366 ecounter -= bbcc->jmp[cjmpNo].ecounter; 367 cjmpNo++; 368 } 369 } 370 } 371 372 373 /* dump out an address with source info if available */ 374 void CLG_(print_addr)(Addr addr) 375 { 376 const HChar *fn_buf, *fl_buf, *dir_buf; 377 const HChar* obj_name; 378 DebugInfo* di; 379 UInt ln, i=0, opos=0; 380 381 if (addr == 0) { 382 VG_(printf)("%08lx", addr); 383 return; 384 } 385 386 CLG_(get_debug_info)(addr, &dir_buf, &fl_buf, &fn_buf, &ln, &di); 387 388 if (VG_(strcmp)(fn_buf,"???")==0) 389 VG_(printf)("%#lx", addr); 390 else 391 VG_(printf)("%#lx %s", addr, fn_buf); 392 393 if (di) { 394 obj_name = VG_(DebugInfo_get_filename)(di); 395 if (obj_name) { 396 while(obj_name[i]) { 397 if (obj_name[i]=='/') opos = i+1; 398 i++; 399 } 400 if (obj_name[0]) 401 VG_(printf)(" %s", obj_name+opos); 402 } 403 } 404 405 if (ln>0) { 406 if (dir_buf[0]) 407 VG_(printf)(" (%s/%s:%u)", dir_buf, fl_buf, ln); 408 else 409 VG_(printf)(" (%s:%u)", fl_buf, ln); 410 } 411 } 412 413 void CLG_(print_addr_ln)(Addr addr) 414 { 415 CLG_(print_addr)(addr); 416 VG_(printf)("\n"); 417 } 418 419 static ULong bb_written = 0; 420 421 void CLG_(print_bbno)(void) 422 { 423 if (bb_written != CLG_(stat).bb_executions) { 424 bb_written = CLG_(stat).bb_executions; 425 VG_(printf)("BB# %llu\n",CLG_(stat).bb_executions); 426 } 427 } 428 429 void CLG_(print_context)(void) 430 { 431 BBCC* bbcc; 432 433 CLG_DEBUG(0,"In tid %u [%d] ", 434 CLG_(current_tid), CLG_(current_call_stack).sp); 435 bbcc = CLG_(current_state).bbcc; 436 print_mangled_cxt(CLG_(current_state).cxt, 437 bbcc ? bbcc->rec_index : 0); 438 VG_(printf)("\n"); 439 } 440 441 void* CLG_(malloc)(const HChar* cc, UWord s, const HChar* f) 442 { 443 CLG_DEBUG(3, "Malloc(%lu) in %s.\n", s, f); 444 return VG_(malloc)(cc,s); 445 } 446 447 #else /* CLG_ENABLE_DEBUG */ 448 449 void CLG_(print_bbno)(void) {} 450 void CLG_(print_context)(void) {} 451 void CLG_(print_jcc)(int s, jCC* jcc) {} 452 void CLG_(print_bbcc)(int s, BBCC* bbcc) {} 453 void CLG_(print_bbcc_fn)(BBCC* bbcc) {} 454 void CLG_(print_cost)(int s, EventSet* es, ULong* cost) {} 455 void CLG_(print_bb)(int s, BB* bb) {} 456 void CLG_(print_cxt)(int s, Context* cxt, int rec_index) {} 457 void CLG_(print_short_jcc)(jCC* jcc) {} 458 void CLG_(print_stackentry)(int s, int sp) {} 459 void CLG_(print_addr)(Addr addr) {} 460 void CLG_(print_addr_ln)(Addr addr) {} 461 462 #endif 463
