callgrind/debug.c

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