Home | History | Annotate | Download | only in callgrind
      1 /*--------------------------------------------------------------------*/
      2 /*--- Callgrind                                                    ---*/
      3 /*---                                                         bb.c ---*/
      4 /*--------------------------------------------------------------------*/
      5 
      6 /*
      7    This file is part of Callgrind, a Valgrind tool for call tracing.
      8 
      9    Copyright (C) 2002-2013, 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 /*------------------------------------------------------------*/
     32 /*--- Basic block (BB) operations                          ---*/
     33 /*------------------------------------------------------------*/
     34 
     35 /* BB hash, resizable */
     36 bb_hash bbs;
     37 
     38 void CLG_(init_bb_hash)()
     39 {
     40    Int i;
     41 
     42    bbs.size    = 8437;
     43    bbs.entries = 0;
     44    bbs.table = (BB**) CLG_MALLOC("cl.bb.ibh.1",
     45                                  bbs.size * sizeof(BB*));
     46 
     47    for (i = 0; i < bbs.size; i++) bbs.table[i] = NULL;
     48 }
     49 
     50 bb_hash* CLG_(get_bb_hash)()
     51 {
     52   return &bbs;
     53 }
     54 
     55 /* The hash stores BBs according to
     56  * - ELF object (is 0 for code in anonymous mapping)
     57  * - BB base as object file offset
     58  */
     59 static __inline__
     60 UInt bb_hash_idx(obj_node* obj, PtrdiffT offset, UInt size)
     61 {
     62   return (((Addr)obj) + offset) % size;
     63 }
     64 
     65 /* double size of bb table  */
     66 static
     67 void resize_bb_table(void)
     68 {
     69     Int i, new_size, conflicts1 = 0, conflicts2 = 0;
     70     BB **new_table, *curr, *next;
     71     UInt new_idx;
     72 
     73     new_size  = 2* bbs.size +3;
     74     new_table = (BB**) CLG_MALLOC("cl.bb.rbt.1",
     75                                   new_size * sizeof(BB*));
     76 
     77     if (!new_table) return;
     78 
     79     for (i = 0; i < new_size; i++)
     80       new_table[i] = NULL;
     81 
     82     for (i = 0; i < bbs.size; i++) {
     83 	if (bbs.table[i] == NULL) continue;
     84 
     85 	curr = bbs.table[i];
     86 	while (NULL != curr) {
     87 	    next = curr->next;
     88 
     89 	    new_idx = bb_hash_idx(curr->obj, curr->offset, new_size);
     90 
     91 	    curr->next = new_table[new_idx];
     92 	    new_table[new_idx] = curr;
     93 	    if (curr->next) {
     94 		conflicts1++;
     95 		if (curr->next->next)
     96 		    conflicts2++;
     97 	    }
     98 
     99 	    curr = next;
    100 	}
    101     }
    102 
    103     VG_(free)(bbs.table);
    104 
    105 
    106     CLG_DEBUG(0, "Resize BB Hash: %d => %d (entries %d, conflicts %d/%d)\n",
    107 	     bbs.size, new_size,
    108 	     bbs.entries, conflicts1, conflicts2);
    109 
    110     bbs.size  = new_size;
    111     bbs.table = new_table;
    112     CLG_(stat).bb_hash_resizes++;
    113 }
    114 
    115 
    116 /**
    117  * Allocate new BB structure (including space for event type list)
    118  * Not initialized:
    119  * - instr_len, cost_count, instr[]
    120  */
    121 static BB* new_bb(obj_node* obj, PtrdiffT offset,
    122 		  UInt instr_count, UInt cjmp_count, Bool cjmp_inverted)
    123 {
    124    BB* bb;
    125    UInt idx, size;
    126 
    127    /* check fill degree of bb hash table and resize if needed (>80%) */
    128    bbs.entries++;
    129    if (10 * bbs.entries / bbs.size > 8)
    130        resize_bb_table();
    131 
    132    size = sizeof(BB) + instr_count * sizeof(InstrInfo)
    133                      + (cjmp_count+1) * sizeof(CJmpInfo);
    134    bb = (BB*) CLG_MALLOC("cl.bb.nb.1", size);
    135    VG_(memset)(bb, 0, size);
    136 
    137    bb->obj        = obj;
    138    bb->offset     = offset;
    139 
    140    bb->instr_count = instr_count;
    141    bb->cjmp_count  = cjmp_count;
    142    bb->cjmp_inverted = cjmp_inverted;
    143    bb->jmp         = (CJmpInfo*) &(bb->instr[instr_count]);
    144    bb->instr_len   = 0;
    145    bb->cost_count  = 0;
    146    bb->sect_kind   = VG_(DebugInfo_sect_kind)(NULL, 0, offset + obj->offset);
    147    bb->fn          = 0;
    148    bb->line        = 0;
    149    bb->is_entry    = 0;
    150    bb->bbcc_list   = 0;
    151    bb->last_bbcc   = 0;
    152 
    153    /* insert into BB hash table */
    154    idx = bb_hash_idx(obj, offset, bbs.size);
    155    bb->next = bbs.table[idx];
    156    bbs.table[idx] = bb;
    157 
    158    CLG_(stat).distinct_bbs++;
    159 
    160 #if CLG_ENABLE_DEBUG
    161    CLG_DEBUGIF(3) {
    162      VG_(printf)("  new_bb (instr %d, jmps %d, inv %s) [now %d]: ",
    163 		 instr_count, cjmp_count,
    164 		 cjmp_inverted ? "yes":"no",
    165 		 CLG_(stat).distinct_bbs);
    166       CLG_(print_bb)(0, bb);
    167       VG_(printf)("\n");
    168    }
    169 #endif
    170 
    171    CLG_(get_fn_node)(bb);
    172 
    173    return bb;
    174 }
    175 
    176 
    177 /* get the BB structure for a BB start address */
    178 static __inline__
    179 BB* lookup_bb(obj_node* obj, PtrdiffT offset)
    180 {
    181     BB* bb;
    182     Int idx;
    183 
    184     idx = bb_hash_idx(obj, offset, bbs.size);
    185     bb = bbs.table[idx];
    186 
    187     while(bb) {
    188       if ((bb->obj == obj) && (bb->offset == offset)) break;
    189       bb = bb->next;
    190     }
    191 
    192     CLG_DEBUG(5, "  lookup_bb (Obj %s, off %#lx): %p\n",
    193 	     obj->name, offset, bb);
    194     return bb;
    195 }
    196 
    197 static __inline__
    198 obj_node* obj_of_address(Addr addr)
    199 {
    200   obj_node* obj;
    201   DebugInfo* di;
    202   PtrdiffT offset;
    203 
    204   di = VG_(find_DebugInfo)(addr);
    205   obj = CLG_(get_obj_node)( di );
    206 
    207   /* Update symbol offset in object if remapped */
    208   /* FIXME (or at least check this) 2008 Feb 19: 'offset' is
    209      only correct for text symbols, not for data symbols */
    210   offset = di ? VG_(DebugInfo_get_text_bias)(di):0;
    211   if (obj->offset != offset) {
    212       Addr start = di ? VG_(DebugInfo_get_text_avma)(di) : 0;
    213 
    214       CLG_DEBUG(0, "Mapping changed for '%s': %#lx -> %#lx\n",
    215 		obj->name, obj->start, start);
    216 
    217       /* Size should be the same, and offset diff == start diff */
    218       CLG_ASSERT( obj->size == (di ? VG_(DebugInfo_get_text_size)(di) : 0) );
    219       CLG_ASSERT( obj->start - start == obj->offset - offset );
    220       obj->offset = offset;
    221       obj->start = start;
    222   }
    223 
    224   return obj;
    225 }
    226 
    227 /* Get the BB structure for a BB start address.
    228  * If the BB has to be created, the IRBB is needed to
    229  * compute the event type list for costs, and seen_before is
    230  * set to False. Otherwise, seen_before is set to True.
    231  *
    232  * BBs are never discarded. There are 2 cases where this function
    233  * is called from CLG_(instrument)() and a BB already exists:
    234  * - The instrumented version was removed from Valgrinds TT cache
    235  * - The ELF object of the BB was unmapped and mapped again.
    236  *   This involves a possibly different address, but is handled by
    237  *   looking up a BB keyed by (obj_node, file offset).
    238  *
    239  * bbIn==0 is possible for artifical BB without real code.
    240  * Such a BB is created when returning to an unknown function.
    241  */
    242 BB* CLG_(get_bb)(Addr addr, IRSB* bbIn, /*OUT*/ Bool *seen_before)
    243 {
    244   BB*   bb;
    245   obj_node* obj;
    246   UInt n_instrs, n_jmps;
    247   Bool cjmp_inverted = False;
    248 
    249   CLG_DEBUG(5, "+ get_bb(BB %#lx)\n", addr);
    250 
    251   obj = obj_of_address(addr);
    252   bb = lookup_bb(obj, addr - obj->offset);
    253 
    254   n_instrs = 0;
    255   n_jmps = 0;
    256   CLG_(collectBlockInfo)(bbIn, &n_instrs, &n_jmps, &cjmp_inverted);
    257 
    258   *seen_before = bb ? True : False;
    259   if (*seen_before) {
    260     if (bb->instr_count != n_instrs) {
    261       VG_(message)(Vg_DebugMsg,
    262 		   "ERROR: BB Retranslation Mismatch at BB %#lx\n", addr);
    263       VG_(message)(Vg_DebugMsg,
    264 		   "  new: Obj %s, Off %#lx, BBOff %#lx, Instrs %u\n",
    265 		   obj->name, obj->offset,
    266 		   addr - obj->offset, n_instrs);
    267       VG_(message)(Vg_DebugMsg,
    268 		   "  old: Obj %s, Off %#lx, BBOff %#lx, Instrs %u\n",
    269 		   bb->obj->name, bb->obj->offset,
    270 		   bb->offset, bb->instr_count);
    271       CLG_ASSERT(bb->instr_count == n_instrs );
    272     }
    273     CLG_ASSERT(bb->cjmp_count == n_jmps );
    274     CLG_(stat).bb_retranslations++;
    275 
    276     CLG_DEBUG(5, "- get_bb(BB %#lx): seen before.\n", addr);
    277     return bb;
    278   }
    279 
    280   bb = new_bb(obj, addr - obj->offset, n_instrs, n_jmps, cjmp_inverted);
    281 
    282   CLG_DEBUG(5, "- get_bb(BB %#lx)\n", addr);
    283 
    284   return bb;
    285 }
    286 
    287 /* Delete the BB info for the bb with unredirected entry-point
    288    address 'addr'. */
    289 void CLG_(delete_bb)(Addr addr)
    290 {
    291     BB  *bb, *bp;
    292     Int idx, size;
    293 
    294     obj_node* obj = obj_of_address(addr);
    295     PtrdiffT offset = addr - obj->offset;
    296 
    297     idx = bb_hash_idx(obj, offset, bbs.size);
    298     bb = bbs.table[idx];
    299 
    300     /* bb points at the current bb under consideration, and bp is the
    301        one before. */
    302     bp = NULL;
    303     while(bb) {
    304       if ((bb->obj == obj) && (bb->offset == offset)) break;
    305       bp = bb;
    306       bb = bb->next;
    307     }
    308 
    309     if (bb == NULL) {
    310 	CLG_DEBUG(3, "  delete_bb (Obj %s, off %#lx): NOT FOUND\n",
    311 		  obj->name, offset);
    312 
    313 	/* we didn't find it.
    314 	 * this happens when callgrinds instrumentation mode
    315 	 * was off at BB translation time, ie. no BB was created.
    316 	 */
    317 	return;
    318     }
    319 
    320     /* unlink it from hash table */
    321 
    322     if (bp == NULL) {
    323        /* we found the first one in the list. */
    324        tl_assert(bb == bbs.table[idx]);
    325        bbs.table[idx] = bb->next;
    326     } else {
    327        tl_assert(bb != bbs.table[idx]);
    328        bp->next = bb->next;
    329     }
    330 
    331     CLG_DEBUG(3, "  delete_bb (Obj %s, off %#lx): %p, BBCC head: %p\n",
    332 	      obj->name, offset, bb, bb->bbcc_list);
    333 
    334     if (bb->bbcc_list == 0) {
    335 	/* can be safely deleted */
    336 
    337 	/* Fill the block up with junk and then free it, so we will
    338 	   hopefully get a segfault if it is used again by mistake. */
    339 	size = sizeof(BB)
    340 	    + bb->instr_count * sizeof(InstrInfo)
    341 	    + (bb->cjmp_count+1) * sizeof(CJmpInfo);
    342 	VG_(memset)( bb, 0xAA, size );
    343 	CLG_FREE(bb);
    344 	return;
    345     }
    346     CLG_DEBUG(3, "  delete_bb: BB in use, can not free!\n");
    347 }
    348