int main(int argc, char **argv) {
dump_link_map(stdout);
printsymbol(printf);
printsymbol(malloc);
printsymbol(dlsym);
struct link_map *map = get_module_by_full_path("/lib64/libdl.so.2");
if (map) {
printf("%s\n", map->l_name);
} else {
printf("not found.\n");
}
}
static
void
directtable(void)
{
profiledata *d;
profilenode *n, *p;
treenode *t;
profiledata m;
size_t i;
unsigned long a, b, c;
double e, f;
cleardata(&m);
printchar(' ', 31);
fputs("DIRECT ALLOCATIONS\n\n", stdout);
printchar(' ', 20);
fprintf(stdout, "(0 < s <= %lu < m <= %lu < l <= %lu < x)\n\n",
sbound, mbound, lbound);
if (showcounts)
{
printchar(' ', 9);
fputs("allocated", stdout);
printchar(' ', 21);
fputs("unfreed\n", stdout);
printchar('-', 27);
fputs(" ", stdout);
printchar('-', 27);
fputs("\n count % s m l x "
"count % s m l x bytes function\n\n", stdout);
}
else
{
printchar(' ', 10);
fputs("allocated", stdout);
printchar(' ', 23);
fputs("unfreed\n", stdout);
printchar('-', 29);
fputs(" ", stdout);
printchar('-', 29);
fputs("\n bytes % s m l x "
"bytes % s m l x count function\n\n", stdout);
}
for (n = (profilenode *) __mp_minimum(proftree.root); n != NULL; n = p)
{
p = (profilenode *) __mp_successor(&n->node);
if (n->data != 0)
{
d = &n->tdata;
sumdata(d, &data[n->data - 1]);
while ((p != NULL) && ((p->addr == n->addr) || (!useaddresses &&
(p->symbol != 0) && (p->symbol == n->symbol))))
{
if (p->data != 0)
sumdata(d, &data[p->data - 1]);
p = (profilenode *) __mp_successor(&p->node);
}
a = 0;
for (i = 0; i < 4; i++)
if (showcounts)
a += d->acount[i];
else
a += d->atotal[i];
__mp_treeinsert(&temptree, &n->tnode, a);
sumdata(&m, d);
}
}
for (t = __mp_maximum(temptree.root); t != NULL; t = __mp_predecessor(t))
{
n = (profilenode *) ((char *) t - offsetof(profilenode, tnode));
d = &n->tdata;
a = t->key;
b = c = 0;
for (i = 0; i < 4; i++)
{
if (showcounts)
{
b += d->dcount[i];
c += d->atotal[i];
}
else
{
b += d->dtotal[i];
c += d->acount[i];
}
d->dcount[i] = d->acount[i] - d->dcount[i];
d->dtotal[i] = d->atotal[i] - d->dtotal[i];
}
b = a - b;
if (showcounts)
{
e = ((double) a / (double) acount) * 100.0;
if (acount != dcount)
f = ((double) b / (double) (acount - dcount)) * 100.0;
else
f = 0.0;
fprintf(stdout, "%6lu %6.2f ", a, e);
printdata(d->acount, acount);
fprintf(stdout, " %6lu %6.2f ", b, f);
printdata(d->dcount, acount - dcount);
fprintf(stdout, " %8lu ", c);
}
else
{
e = ((double) a / (double) atotal) * 100.0;
if (atotal != dtotal)
f = ((double) b / (double) (atotal - dtotal)) * 100.0;
else
f = 0.0;
fprintf(stdout, "%8lu %6.2f ", a, e);
printdata(d->atotal, atotal);
fprintf(stdout, " %8lu %6.2f ", b, f);
printdata(d->dtotal, atotal - dtotal);
fprintf(stdout, " %6lu ", c);
}
printsymbol(stdout, n);
fputc('\n', stdout);
cleardata(d);
}
for (i = 0; i < 4; i++)
{
m.dcount[i] = m.acount[i] - m.dcount[i];
m.dtotal[i] = m.atotal[i] - m.dtotal[i];
}
if (temptree.size != 0)
fputc('\n', stdout);
if (showcounts)
{
fprintf(stdout, "%6lu ", acount);
printdata(m.acount, acount);
fprintf(stdout, " %6lu ", acount - dcount);
printdata(m.dcount, acount - dcount);
fprintf(stdout, " %8lu total\n", atotal);
}
else
{
fprintf(stdout, "%8lu ", atotal);
printdata(m.atotal, atotal);
fprintf(stdout, " %8lu ", atotal - dtotal);
printdata(m.dtotal, atotal - dtotal);
fprintf(stdout, " %6lu total\n", acount);
}
__mp_newtree(&temptree);
}
static
void
writegraph(profilenode *p, graphnode *n)
{
listnode *l;
vertex *v;
edge *e;
graphedge *g;
size_t i, t;
for (l = n->children.head; l->next != NULL; l = l->next)
{
/* The following three lines are a bit excessive and result from
* using class-based programming in C. These conversions would be
* automatically calculated by the compiler if we were using C++
* classes.
*/
g = (graphedge *) ((char *) l - offsetof(graphedge, cnode));
e = (edge *) ((char *) g - offsetof(edge, gnode));
v = (vertex *) ((char *) e->gnode.child - offsetof(vertex, gnode));
if (!(e->flags & 1))
{
e->flags |= 1;
for (i = t = 0; i < 4; i++)
if (showcounts)
{
t += e->data.acount[i];
if (showleaks)
t -= e->data.dcount[i];
}
else
{
t += e->data.atotal[i];
if (showleaks)
t -= e->data.dtotal[i];
}
if ((t > 0) || !showleaks)
{
fputs(" \"", graphfile);
if (p == NULL)
fputs("START", graphfile);
else
printsymbol(graphfile, p);
fputs("\" -> \"", graphfile);
if (&v->gnode == &graph.end)
fputs("ALLOC", graphfile);
else
printsymbol(graphfile, v->pnode);
fprintf(graphfile, "\" [label = \"%lu\"", t);
if (e->flags & 2)
fputs(", style = dotted", graphfile);
fputs("];\n", graphfile);
}
writegraph(v->pnode, &v->gnode);
}
}
if (p == NULL)
for (e = (edge *) edgelist.head; e->node.next != NULL;
e = (edge *) e->node.next)
e->flags &= ~1;
}
static
void
callgraph(void)
{
size_t d[4];
listnode *l;
vertex *u, *v;
edge *e;
graphedge *g;
size_t i, s, t;
i = 1;
printchar(' ', 29);
fputs("ALLOCATION CALL GRAPH\n\n", stdout);
printchar(' ', 28);
fprintf(stdout, "(number of vertices: %lu)\n\n", temptree.size);
if (showcounts)
{
printchar(' ', 10);
fputs("allocated", stdout);
printchar(' ', 13);
fputs("unfreed\n", stdout);
printchar(' ', 5);
printchar('-', 19);
fputs(" ", stdout);
printchar('-', 19);
fputs("\nindex count s m l x count s m l x function\n",
stdout);
}
else
{
printchar(' ', 11);
fputs("allocated", stdout);
printchar(' ', 15);
fputs("unfreed\n", stdout);
printchar(' ', 5);
printchar('-', 21);
fputs(" ", stdout);
printchar('-', 21);
fputs("\nindex bytes s m l x bytes s m l x function\n",
stdout);
}
/* Compute the index for each vertex in the graph. This is currently
* done after the graph has been completely constructed so that the
* ordering can be done by code address. It has to be done before we
* start displaying the graph since each vertex will contain forward
* references to its parents and children.
*/
for (v = (vertex *) __mp_minimum(temptree.root); v != NULL;
v = (vertex *) __mp_successor(&v->node))
v->index = i++;
for (v = (vertex *) __mp_minimum(temptree.root); v != NULL;
v = (vertex *) __mp_successor(&v->node))
{
if (showcounts)
printchar('-', 45);
else
printchar('-', 49);
fputc('\n', stdout);
/* Calculate the details of the parents.
*/
for (l = v->gnode.parents.head; l->next != NULL; l = l->next)
{
/* The following three lines are a bit excessive and result from
* using class-based programming in C. These conversions would be
* automatically calculated by the compiler if we were using C++
* classes.
*/
g = (graphedge *) ((char *) l - offsetof(graphedge, pnode));
e = (edge *) ((char *) g - offsetof(edge, gnode));
u = (vertex *) ((char *) e->gnode.parent - offsetof(vertex, gnode));
if (&u->gnode != &graph.start)
{
for (i = s = t = 0; i < 4; i++)
{
if (showcounts)
{
t += e->data.acount[i];
d[i] = e->data.acount[i] - e->data.dcount[i];
}
else
{
t += e->data.atotal[i];
d[i] = e->data.atotal[i] - e->data.dtotal[i];
}
s += d[i];
}
if (e->flags & 2)
fputs(" (*) ", stdout);
else
printchar(' ', 5);
if (showcounts)
{
fprintf(stdout, "%6lu ", t);
printdata(e->data.acount, t);
fprintf(stdout, " %6lu ", s);
}
else
{
fprintf(stdout, "%8lu ", t);
printdata(e->data.atotal, t);
fprintf(stdout, " %8lu ", s);
}
printdata(d, s);
printchar(' ', 6);
printsymbol(stdout, u->pnode);
fprintf(stdout, " [%lu]\n", u->index);
}
}
fprintf(stdout, "[%lu] ", v->index);
if (showcounts)
printchar(' ', 44 - countdigits(v->index));
else
printchar(' ', 48 - countdigits(v->index));
printsymbol(stdout, v->pnode);
fprintf(stdout, " [%lu]\n", v->index);
/* Calculate the details of the children.
*/
for (l = v->gnode.children.head; l->next != NULL; l = l->next)
{
/* The following three lines are a bit excessive and result from
* using class-based programming in C. These conversions would be
* automatically calculated by the compiler if we were using C++
* classes.
*/
g = (graphedge *) ((char *) l - offsetof(graphedge, cnode));
e = (edge *) ((char *) g - offsetof(edge, gnode));
u = (vertex *) ((char *) e->gnode.child - offsetof(vertex, gnode));
if (&u->gnode != &graph.end)
{
for (i = s = t = 0; i < 4; i++)
{
if (showcounts)
{
t += e->data.acount[i];
d[i] = e->data.acount[i] - e->data.dcount[i];
}
else
{
t += e->data.atotal[i];
d[i] = e->data.atotal[i] - e->data.dtotal[i];
}
s += d[i];
}
if (e->flags & 2)
fputs(" (*) ", stdout);
else
printchar(' ', 5);
if (showcounts)
{
fprintf(stdout, "%6lu ", t);
printdata(e->data.acount, t);
fprintf(stdout, " %6lu ", s);
}
else
{
fprintf(stdout, "%8lu ", t);
printdata(e->data.atotal, t);
fprintf(stdout, " %8lu ", s);
}
printdata(d, s);
printchar(' ', 6);
printsymbol(stdout, u->pnode);
fprintf(stdout, " [%lu]\n", u->index);
}
}
}
}
static
void
leaktable(void)
{
profiledata *d;
profilenode *n, *p;
treenode *t;
size_t i;
unsigned long a, b, j, k;
double e, f, g;
printchar(' ', 34);
fputs("MEMORY LEAKS\n\n", stdout);
printchar(' ', 28);
fprintf(stdout, "(maximum stack depth: %lu)\n\n", maxstack);
printchar(' ', 16);
fputs("unfreed", stdout);
printchar(' ', 22);
fputs("allocated\n", stdout);
printchar('-', 40);
fputs(" ", stdout);
printchar('-', 16);
if (showcounts)
fputs("\n % count % bytes % "
"count bytes function\n\n", stdout);
else
fputs("\n % bytes % count % "
"bytes count function\n\n", stdout);
for (n = (profilenode *) __mp_minimum(proftree.root); n != NULL; n = p)
{
p = (profilenode *) __mp_successor(&n->node);
if ((n->data != 0) && !n->flags)
{
d = &n->tdata;
sumdata(d, &data[n->data - 1]);
while ((p != NULL) && ((p->addr == n->addr) || (!useaddresses &&
(p->symbol != 0) && (p->symbol == n->symbol))))
{
if ((p->data != 0) && !p->flags && comparestack(n, p, 0))
{
sumdata(d, &data[p->data - 1]);
p->flags = 1;
}
p = (profilenode *) __mp_successor(&p->node);
}
p = (profilenode *) __mp_successor(&n->node);
a = 0;
for (i = 0; i < 4; i++)
if (showcounts)
a += d->acount[i] - d->dcount[i];
else
a += d->atotal[i] - d->dtotal[i];
if (a > 0)
__mp_treeinsert(&temptree, &n->tnode, a);
}
}
for (n = (profilenode *) __mp_minimum(proftree.root); n != NULL;
n = (profilenode *) __mp_successor(&n->node))
n->flags = 0;
for (t = __mp_maximum(temptree.root); t != NULL; t = __mp_predecessor(t))
{
n = (profilenode *) ((char *) t - offsetof(profilenode, tnode));
d = &n->tdata;
a = t->key;
b = j = k = 0;
for (i = 0; i < 4; i++)
if (showcounts)
{
b += d->dtotal[i];
j += d->acount[i];
k += d->atotal[i];
}
else
{
b += d->dcount[i];
j += d->atotal[i];
k += d->acount[i];
}
b = k - b;
e = ((double) a / (double) j) * 100.0;
f = ((double) b / (double) k) * 100.0;
if (showcounts)
{
g = ((double) a / (double) (acount - dcount)) * 100.0;
fprintf(stdout, "%6.2f %6lu %6.2f %8lu %6.2f %6lu %8lu ",
g, a, e, b, f, j, k);
}
else
{
g = ((double) a / (double) (atotal - dtotal)) * 100.0;
fprintf(stdout, "%6.2f %8lu %6.2f %6lu %6.2f %8lu %6lu ",
g, a, e, b, f, j, k);
}
printsymbol(stdout, n);
fputc('\n', stdout);
p = n;
for (i = 1; (maxstack == 0) || (i < maxstack); i++)
{
if (p->parent == 0)
break;
p = &nodes[p->parent - 1];
printchar(' ', 60);
printsymbol(stdout, p);
fputc('\n', stdout);
}
cleardata(d);
}
if (acount != 0)
e = ((double) (acount - dcount) / (double) acount) * 100.0;
else
e = 0.0;
if (atotal != 0)
f = ((double) (atotal - dtotal) / (double) atotal) * 100.0;
else
f = 0.0;
if (temptree.size != 0)
fputc('\n', stdout);
if (showcounts)
fprintf(stdout, " %6lu %6.2f %8lu %6.2f %6lu %8lu total\n",
acount - dcount, e, atotal - dtotal, f, acount, atotal);
else
fprintf(stdout, " %8lu %6.2f %6lu %6.2f %8lu %6lu total\n",
atotal - dtotal, f, acount - dcount, e, atotal, acount);
__mp_newtree(&temptree);
}
