]> Git Repo - binutils.git/blob - gprofng/src/Hist_data.cc
Automatic date update in version.in
[binutils.git] / gprofng / src / Hist_data.cc
1 /* Copyright (C) 2021 Free Software Foundation, Inc.
2    Contributed by Oracle.
3
4    This file is part of GNU Binutils.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3, or (at your option)
9    any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "config.h"
22 #include <assert.h>
23
24 #include "util.h"
25 #include "DefaultMap.h"
26 #include "DbeSession.h"
27 #include "Experiment.h"
28 #include "DataObject.h"
29 #include "Function.h"
30 #include "Hist_data.h"
31 #include "Histable.h"
32 #include "MemObject.h"
33 #include "IndexObject.h"
34 #include "MetricList.h"
35 #include "Metric.h"
36 #include "Module.h"
37 #include "LoadObject.h"
38 #include "Settings.h"
39 #include "StringBuilder.h"
40 #include "ExpGroup.h"
41 #include "PathTree.h"
42 #include "DbeView.h"
43 #include "FileData.h"
44
45 Hist_data::HistItem::HistItem (long n)
46 {
47   obj = NULL;
48   type = 0;
49   size = n;
50   value = new TValue[n];
51   memset (value, 0, sizeof (TValue) * n);
52 }
53
54 Hist_data::HistItem::~HistItem ()
55 {
56   for (long i = 0; i < size; i++)
57     if (value[i].tag == VT_LABEL)
58       free (value[i].l);
59   delete[] value;
60 }
61
62 long
63 Hist_data::size ()
64 {
65   // If the data values have not been computed, do so
66   // Return the total number of items
67   return hist_items->size ();
68 }
69
70 Hist_data::HistItem *
71 Hist_data::fetch (long index)
72 {
73   return (index < VecSize (hist_items)) ? hist_items->get (index) : NULL;
74 }
75
76 int
77 Hist_data::sort_compare (HistItem *hi_1, HistItem *hi_2, Sort_type stype,
78                          long ind, Hist_data *hdata)
79 {
80   // Sort the data depending upon order and type
81   int result = 0;
82   Histable::Type type = hi_1->obj->get_type ();
83   if (stype == ALPHA)
84     {
85       if (type != Histable::MEMOBJ && type != Histable::INDEXOBJ
86               && type != Histable::IOACTVFD && type != Histable::IOACTFILE
87               && type != Histable::IOCALLSTACK)
88         {
89           char *nm1 = hi_1->obj->get_name ();
90           char *nm2 = hi_2->obj->get_name ();
91           if (nm1 != NULL && nm2 != NULL)
92             result = strcoll (nm1, nm2);
93         }
94       else if (type == Histable::IOCALLSTACK || type == Histable::IOACTVFD
95                || type == Histable::IOACTFILE)
96         {
97           uint64_t idx1, idx2;
98           idx1 = ((FileData *) (hi_1->obj))->get_index ();
99           idx2 = ((FileData *) (hi_2->obj))->get_index ();
100           if (idx1 < idx2)
101             result = -1;
102           else if (idx1 > idx2)
103             result = 1;
104           else
105             result = 0;
106         }
107       else
108         {
109           // for memory and index objects, "alphabetic" is really by index
110           // <Total> has index -2, and always comes first
111           // <Unknown> has index -1, and always comes second.
112           uint64_t i1, i2;
113           bool needsStringCompare = false;
114           if (type == Histable::MEMOBJ)
115             {
116               i1 = ((MemObj *) (hi_1->obj))->get_index ();
117               i2 = ((MemObj *) (hi_2->obj))->get_index ();
118             }
119           else if (type == Histable::INDEXOBJ)
120             {
121               i1 = ((IndexObject *) (hi_1->obj))->get_index ();
122               i2 = ((IndexObject *) (hi_2->obj))->get_index ();
123               needsStringCompare =
124                       ((IndexObject *) (hi_1->obj))->requires_string_sort ();
125             }
126           else
127             abort ();
128           if (i1 == (uint64_t) - 2)
129             result = -1;
130           else if (i2 == (uint64_t) - 2)
131             result = 1;
132           else if (i1 == (uint64_t) - 1)
133             result = -1;
134           else if (i2 == (uint64_t) - 1)
135             result = 1;
136           else if (needsStringCompare)
137             {
138               char *nm1 = hi_1->obj->get_name ();
139               char *nm2 = hi_2->obj->get_name ();
140               if (nm1 != NULL && nm2 != NULL)
141                 {
142                   char nm1_lead = nm1[0];
143                   char nm2_lead = nm2[0];
144                   // put "(unknown)" and friends at end of list
145                   if (nm1_lead == '(' && nm1_lead != nm2_lead)
146                     result = 1;
147                   else if (nm2_lead == '(' && nm1_lead != nm2_lead)
148                     result = -1;
149                   else
150                     result = strcoll (nm1, nm2);
151                 }
152             }
153           if (result == 0)
154             { // matches, resolve by index
155               if (i1 < i2)
156                 result = -1;
157               else if (i1 > i2)
158                 result = 1;
159             }
160         }
161     }
162   else if (stype == AUX)
163     {
164       switch (type)
165         {
166         case Histable::INSTR:
167           {
168             DbeInstr *instr1 = (DbeInstr*) hi_1->obj;
169             DbeInstr *instr2 = (DbeInstr*) hi_2->obj;
170             result = instr1 ? instr1->pc_cmp (instr2) : instr2 ? 1 : 0;
171             break;
172           }
173         case Histable::LINE:
174           {
175             DbeLine *dbl1 = (DbeLine*) hi_1->obj;
176             DbeLine *dbl2 = (DbeLine*) hi_2->obj;
177             result = dbl1->line_cmp (dbl2);
178           }
179           break;
180         default:
181           assert (0);
182         }
183     }
184   else if (stype == VALUE)
185     {
186       Metric *m = hdata->get_metric_list ()->get (ind);
187       if ((m->get_visbits () & (VAL_DELTA | VAL_RATIO)) != 0)
188         {
189           TValue v1, v2;
190           int first_ind = hdata->hist_metrics[ind].indFirstExp;
191           if ((m->get_visbits () & VAL_DELTA) != 0)
192             {
193               v1.make_delta (hi_1->value + ind, hi_1->value + first_ind);
194               v2.make_delta (hi_2->value + ind, hi_2->value + first_ind);
195             }
196           else
197             {
198               v1.make_ratio (hi_1->value + ind, hi_1->value + first_ind);
199               v2.make_ratio (hi_2->value + ind, hi_2->value + first_ind);
200             }
201           result = v1.compare (&v2);
202         }
203       else
204         result = hi_1->value[ind].compare (hi_2->value + ind);
205     }
206   return result;
207 }
208
209 int
210 Hist_data::sort_compare_all (const void *a, const void *b, const void *arg)
211 {
212   HistItem *hi_1 = *((HistItem **) a);
213   HistItem *hi_2 = *((HistItem **) b);
214
215   Hist_data *hdata = (Hist_data*) arg;
216   int result = sort_compare (hi_1, hi_2, hdata->sort_type, hdata->sort_ind, hdata);
217   if (hdata->sort_order == DESCEND)
218     result = -result;
219
220   // Use the name as the 2d sort key (always ASCEND)
221   // except for MemoryObjects and  IndexObjects, where the index is used
222   // For the Alphabetic sort
223   if (result == 0)
224     {
225       result = sort_compare (hi_1, hi_2, ALPHA, 0, NULL);
226       if (result == 0)
227         {
228           for (long i = 0, sz = hdata->metrics->size (); i < sz; i++)
229             {
230               Metric *m = hdata->metrics->get (i);
231               if (m->get_type () != Metric::ONAME)
232                 {
233                   result = sort_compare (hi_1, hi_2, VALUE, i, hdata);
234                   if (result != 0)
235                     {
236                       if (hdata->sort_order == DESCEND)
237                         result = -result;
238                       break;
239                     }
240                 }
241             }
242         }
243     }
244
245   // Use the address as the 3d sort key
246   // ( FUNCTION only, always ASCEND )
247   if (result == 0 && hi_1->obj->get_type () == Histable::FUNCTION)
248     {
249       Function *f1 = (Function*) hi_1->obj;
250       Function *f2 = (Function*) hi_2->obj;
251       if (f1->get_addr () < f2->get_addr ())
252         result = -1;
253       else if (f1->get_addr () > f2->get_addr ())
254         result = 1;
255     }
256
257   // Use the Histable id (ID of function, line, etc.) as the 4th sort key
258   // Note that IDs are not guaranteed to be stable,
259   if (result == 0)
260     {
261       if (hi_1->obj->id < hi_2->obj->id)
262         result = -1;
263       else if (hi_1->obj->id > hi_2->obj->id)
264         result = 1;
265     }
266
267   if (result == 0)
268     return result; // shouldn't happen in most cases; line allows for breakpoint
269   if (hdata->rev_sort)
270     result = -result;
271   return result;
272 }
273
274 int
275 Hist_data::sort_compare_dlayout (const void *a, const void *b, const void *arg)
276 {
277   assert ((a != (const void *) NULL));
278   assert ((b != (const void *) NULL));
279   HistItem *hi_1 = *((HistItem **) a);
280   HistItem *hi_2 = *((HistItem **) b);
281   DataObject * dobj1 = (DataObject *) (hi_1->obj);
282   DataObject * dobj2 = (DataObject *) (hi_2->obj);
283   DataObject * parent1 = dobj1->parent;
284   DataObject * parent2 = dobj2->parent;
285
286   Hist_data *hdata = (Hist_data*) arg;
287
288   // are the two items members of the same object?
289   if (parent1 == parent2)
290     {
291       // yes
292       if (parent1)
293         {
294           // and they have real parents...
295           if (parent1->get_typename ())
296             { // element
297               // use dobj1/dobj2 offset for sorting
298               uint64_t off1 = dobj1->get_offset ();
299               uint64_t off2 = dobj2->get_offset ();
300               if (off1 < off2)
301                 return -1;
302               if (off1 > off2)
303                 return 1;
304               return 0;
305             }
306         }
307     }
308   else
309     { // parents differ
310       if (parent1)
311         {
312           if (parent1 == dobj2)
313             // sorting an object and its parent: parent always first
314             return 1;
315           dobj1 = parent1;
316         }
317       if (parent2)
318         {
319           if (parent2 == dobj1)
320             return -1;
321           dobj2 = parent2;
322         }
323     }
324   //  Either two unknowns, or two scalars, or two parents
325   hi_1 = hdata->hi_map->get (dobj1);
326   hi_2 = hdata->hi_map->get (dobj2);
327   return sort_compare_all ((const void*) &hi_1, (const void*) &hi_2, hdata);
328 }
329
330 Hist_data::Hist_data (MetricList *_metrics, Histable::Type _type,
331                       Hist_data::Mode _mode, bool _viewowned)
332 {
333   hist_items = new Vector<HistItem*>;
334   metrics = _metrics;
335   nmetrics = metrics->get_items ()->size ();
336   type = _type;
337   mode = _mode;
338   gprof_item = new_hist_item (NULL);
339   viewowned = _viewowned;
340   sort_ind = -1;
341   rev_sort = false;
342
343   Histable *tobj = new Other;
344   tobj->name = dbe_strdup (NTXT ("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
345   minimum = new_hist_item (tobj);
346
347   tobj = new Other;
348   tobj->name = dbe_strdup (NTXT (""));
349   maximum = new_hist_item (tobj);
350
351   tobj = new Other;
352   tobj->name = dbe_strdup (NTXT ("xxxxxxxxxxxxxxxxxxxxxx"));
353   maximum_inc = new_hist_item (tobj);
354
355   tobj = new Other;
356   tobj->name = dbe_strdup (NTXT ("<Total>"));
357   total = new_hist_item (tobj);
358
359   tobj = new Other;
360   tobj->name = dbe_strdup (NTXT ("XXXX Threshold XXXX"));
361   threshold = new_hist_item (tobj);
362
363   hi_map = new HashMap<Histable*, HistItem*>;
364   callsite_mark = new DefaultMap<Histable*, int>;
365   hist_metrics = new Metric::HistMetric[metrics->size ()];
366   for (long i = 0, sz = metrics->size (); i < sz; i++)
367     {
368       Metric::HistMetric *h = hist_metrics + i;
369       h->init ();
370       Metric *m = metrics->get (i);
371       if (0 != (m->get_visbits () & (VAL_DELTA | VAL_RATIO)))
372         h->indFirstExp =
373               metrics->get_listorder (m->get_cmd (),
374                                       m->get_subtype (), "EXPGRID==1");
375       if (m->is_tvisible () && m->get_type () == BaseMetric::HWCNTR
376           && m->get_dependent_bm ())
377         h->indTimeVal =
378               metrics->get_listorder (m->get_dependent_bm ()->get_cmd (),
379                                       m->get_subtype (), m->get_expr_spec ());
380     }
381   status = NO_DATA;
382 }
383
384 Hist_data::~Hist_data ()
385 {
386   delete[] hist_metrics;
387   if (hist_items)
388     {
389       hist_items->destroy ();
390       delete hist_items;
391       hist_items = NULL;
392     }
393   if (gprof_item)
394     {
395       delete gprof_item;
396       gprof_item = NULL;
397     }
398   if (maximum)
399     {
400       delete maximum->obj;
401       delete maximum;
402       maximum = NULL;
403     }
404   if (maximum_inc)
405     {
406       delete maximum_inc->obj;
407       delete maximum_inc;
408       maximum_inc = NULL;
409     }
410   if (minimum)
411     {
412       delete minimum->obj;
413       delete minimum;
414       minimum = NULL;
415     }
416   if (total)
417     {
418       delete total->obj;
419       delete total;
420       total = NULL;
421     }
422   if (threshold)
423     {
424       delete threshold->obj;
425       delete threshold;
426       threshold = NULL;
427     }
428   delete metrics;
429   delete hi_map;
430   delete callsite_mark;
431 }
432
433 void
434 Hist_data::dump (char *msg, FILE *f)
435 {
436   fprintf (f, "   Hist_data dump:  %s\n", msg);
437   fprintf (f, "      %d=%d metrics\n", (int) nmetrics, (int) metrics->size ());
438   for (int i = 0; i < nmetrics; i++)
439     {
440       Metric *m = metrics->get_items ()->fetch (i);
441       char *s = m->get_expr_spec ();
442       fprintf (f, "          %4d %15s %4d %15s\n", i, m->get_mcmd (0),
443                m->get_id (), s ? s : "(NULL)");
444     }
445
446   fprintf (f, NTXT ("      HistItem listing\n"));
447   int n = hist_items->size ();
448   for (int j = -1; j < n; j++)
449     {
450       HistItem *hi;
451       if (j < 0)
452         {
453           hi = total;
454           fprintf (f, NTXT ("                         total"));
455         }
456       else
457         {
458           hi = hist_items->fetch (j);
459           fprintf (f, NTXT ("%30s"), hi->obj->get_name ());
460         }
461       for (int i = 0; i < nmetrics; i++)
462         {
463           char *stmp = hi->value[i].l;
464           switch (hi->value[i].tag)
465             {
466             case VT_SHORT: fprintf (f, NTXT (" %d"), hi->value[i].s);
467               break;
468             case VT_INT: fprintf (f, NTXT (" %d"), hi->value[i].i);
469               break;
470             case VT_LLONG: fprintf (f, NTXT (" %12lld"), hi->value[i].ll);
471               break;
472             case VT_FLOAT: fprintf (f, NTXT (" %f"), hi->value[i].f);
473               break;
474             case VT_DOUBLE: fprintf (f, NTXT (" %12.6lf"), hi->value[i].d);
475               break;
476             case VT_HRTIME: fprintf (f, NTXT (" %12llu"), hi->value[i].ull);
477               break;
478             case VT_LABEL: fprintf (f, NTXT (" %s"), stmp ? stmp: "(unnamed)");
479               break;
480             case VT_ADDRESS: fprintf (f, NTXT (" %12lld"), hi->value[i].ll);
481               break;
482             case VT_OFFSET: fprintf (f, NTXT (" %p"), hi->value[i].p);
483               break;
484             case VT_ULLONG: fprintf (f, NTXT (" %12llu"), hi->value[i].ull);
485               break;
486             default: fprintf (f, NTXT ("     "));
487               break;
488             }
489         }
490       fprintf (f, NTXT ("\n"));
491     }
492 }
493
494 void
495 Hist_data::sort (long ind, bool reverse)
496 {
497   if (mode != MODL && ind != -1 && ind == sort_ind && reverse == rev_sort)
498     // there's no change to the sorting
499     return;
500
501   if (mode == MODL)
502     {
503       sort_type = AUX;
504       sort_order = ASCEND;
505     }
506   else
507     {
508       if (ind == -1)
509         return;
510       Metric::Type mtype = metrics->get_items ()->fetch (ind)->get_type ();
511       sort_type = mtype == Metric::ONAME ? ALPHA : VALUE;
512       sort_order = (mtype == Metric::ONAME || mtype == Metric::ADDRESS) ?
513               ASCEND : DESCEND;
514       sort_ind = ind;
515       rev_sort = reverse;
516     }
517
518   if (mode == Hist_data::LAYOUT || mode == Hist_data::DETAIL)
519     hist_items->sort ((CompareFunc) sort_compare_dlayout, this);
520   else
521     hist_items->sort ((CompareFunc) sort_compare_all, this);
522
523   // ensure that <Total> comes first/last
524   char *tname = NTXT ("<Total>");
525   for (int i = 0; i < hist_items->size (); ++i)
526     {
527       HistItem *hi = hist_items->fetch (i);
528       char *name = hi->obj->get_name ();
529       if (name != NULL && streq (name, tname))
530         {
531           int idx0 = rev_sort ? hist_items->size () - 1 : 0;
532           if (i != idx0)
533             {
534               hist_items->remove (i);
535               hist_items->insert (idx0, hi);
536             }
537           break;
538         }
539     }
540 }
541
542 void
543 Hist_data::resort (MetricList *mlist)
544 {
545   if (mlist->get_type () != metrics->get_type ())
546     if (metrics->get_type () == MET_CALL)
547       // wrong type of list -- internal error
548       abort ();
549
550   // get the new sort order
551   int ind = mlist->get_sort_ref_index ();
552   bool reverse = mlist->get_sort_rev ();
553   sort (ind, reverse);
554 }
555
556 void
557 Hist_data::compute_minmax ()
558 {
559   HistItem *hi;
560   int index;
561
562   for (int mind = 0; mind < nmetrics; mind++)
563     {
564       Metric *mtr = metrics->get_items ()->fetch (mind);
565       if (mtr->get_subtype () == Metric::STATIC)
566         continue;
567       if (!mtr->is_visible () && !mtr->is_tvisible () && !mtr->is_pvisible ())
568         continue;
569       ValueTag vtype = mtr->get_vtype2 ();
570
571       switch (vtype)
572         {
573         case VT_INT:
574           minimum->value[mind].tag = VT_INT;
575           minimum->value[mind].i = 0;
576           maximum->value[mind].tag = VT_INT;
577           maximum->value[mind].i = 0;
578           maximum_inc->value[mind].tag = VT_INT;
579           maximum_inc->value[mind].i = 0;
580
581           Vec_loop (HistItem *, hist_items, index, hi)
582           {
583             if (metrics->get_type () == MET_SRCDIS
584                 && callsite_mark->get (hi->obj))
585               {
586                 if (hi->value[mind].i > maximum_inc->value[mind].i)
587                   maximum_inc->value[mind].i = hi->value[mind].i;
588                 // ignore ones that has inclusive time for src/dis view
589               }
590             else if (hi->value[mind].i > maximum->value[mind].i)
591               maximum->value[mind].i = hi->value[mind].i;
592             if (hi->value[mind].i < minimum->value[mind].i)
593               minimum->value[mind].i = hi->value[mind].i;
594           }
595           break;
596         case VT_DOUBLE:
597           minimum->value[mind].tag = VT_DOUBLE;
598           minimum->value[mind].d = 0.0;
599           maximum->value[mind].tag = VT_DOUBLE;
600           maximum->value[mind].d = 0.0;
601           maximum_inc->value[mind].tag = VT_DOUBLE;
602           maximum_inc->value[mind].d = 0.0;
603           Vec_loop (HistItem*, hist_items, index, hi)
604           {
605             if (metrics->get_type () == MET_SRCDIS && callsite_mark->get (hi->obj))
606               {
607                 if (hi->value[mind].d > maximum_inc->value[mind].d)
608                   {
609                     maximum_inc->value[mind].d = hi->value[mind].d;
610                     maximum_inc->value[mind].sign = hi->value[mind].sign;
611                   }
612                 // ignore ones that has inclusive time for src/dis view
613               }
614             else
615               {
616                 if (hi->value[mind].d > maximum->value[mind].d)
617                   {
618                     maximum->value[mind].d = hi->value[mind].d;
619                     maximum->value[mind].sign = hi->value[mind].sign;
620                   }
621                 if (hi->value[mind].d < minimum->value[mind].d)
622                   {
623                     minimum->value[mind].d = hi->value[mind].d;
624                     minimum->value[mind].sign = hi->value[mind].sign;
625                   }
626               }
627           }
628           break;
629         case VT_LLONG:
630         case VT_ULLONG:
631         case VT_ADDRESS:
632           minimum->value[mind].tag = vtype;
633           minimum->value[mind].ll = 0;
634           maximum->value[mind].tag = vtype;
635           maximum->value[mind].ll = 0;
636           maximum_inc->value[mind].tag = vtype;
637           maximum_inc->value[mind].ll = 0;
638           Vec_loop (HistItem*, hist_items, index, hi)
639           {
640             if (metrics->get_type () == MET_SRCDIS && callsite_mark->get (hi->obj))
641               {
642                 if (hi->value[mind].ll > maximum_inc->value[mind].ll)
643                   {
644                     maximum_inc->value[mind].ll = hi->value[mind].ll;
645                     maximum_inc->value[mind].sign = hi->value[mind].sign;
646                   }
647                 // ignore ones that has inclusive time for src/dis view
648               }
649             else
650               {
651                 if (hi->value[mind].ll > maximum->value[mind].ll)
652                   {
653                     maximum->value[mind].ll = hi->value[mind].ll;
654                     maximum->value[mind].sign = hi->value[mind].sign;
655                   }
656                 if (hi->value[mind].ll < minimum->value[mind].ll)
657                   {
658                     minimum->value[mind].ll = hi->value[mind].ll;
659                     minimum->value[mind].sign = hi->value[mind].sign;
660                   }
661               }
662           }
663           break;
664         default:
665           break;
666         }
667     }
668 }
669
670 Hist_data::HistItem *
671 Hist_data::new_hist_item (Histable *obj)
672 {
673   long sz = get_metric_list ()->size ();
674   HistItem *hi = new HistItem (sz);
675   hi->obj = obj;
676
677   // We precalculate all metrics as integer values
678   // and convert them to appropriate types later.
679   for (long i = 0; i < sz; i++)
680     {
681       hi->value[i].tag = VT_INT;
682       hi->value[i].i = 0;
683     }
684   return hi;
685 }
686
687 Hist_data::HistItem *
688 Hist_data::new_hist_item (Histable *obj, int itype, TValue *value)
689 {
690   long sz = get_metric_list ()->size ();
691   HistItem *hi = new HistItem (sz);
692   hi->obj = obj;
693   hi->type = itype;
694   if (value)
695     for (long i = 0; i < sz; i++)
696       hi->value[i] = value[i];
697
698   return hi;
699 }
700
701 Hist_data::HistItem *
702 Hist_data::find_hist_item (Histable *obj)
703 {
704   if (obj == NULL)
705     return NULL;
706   return hi_map->get (obj);
707 }
708
709 Hist_data::HistItem *
710 Hist_data::append_hist_item (Histable *obj)
711 {
712   if (obj == NULL)
713     return NULL;
714   HistItem *hi = hi_map->get (obj);
715   if (hi == NULL)
716     {
717       hi = new_hist_item (obj);
718       hist_items->append (hi);
719       hi_map->put (obj, hi);
720     }
721   if (status == NO_DATA)
722     status = SUCCESS;
723   return hi;
724 }
725
726 void
727 Hist_data::append_hist_item (HistItem *hi)
728 {
729   hist_items->append (hi);
730 }
731
732 bool
733 Hist_data::above_threshold (HistItem* hi)
734 {
735   bool mark = false;
736   int index;
737   Metric *mitem;
738
739   Vec_loop (Metric*, metrics->get_items (), index, mitem)
740   {
741     if (mitem->get_subtype () == Metric::STATIC)
742       continue;
743     switch (hi->value[index].tag)
744       {
745       case VT_DOUBLE:
746         if (hi->value[index].d > threshold->value[index].d)
747           mark = true;
748         break;
749       case VT_INT:
750         if (hi->value[index].i > threshold->value[index].i)
751           mark = true;
752         break;
753       case VT_LLONG:
754         if (hi->value[index].ll > threshold->value[index].ll)
755           mark = true;
756         break;
757       case VT_ULLONG:
758         if (hi->value[index].ull > threshold->value[index].ull)
759           mark = true;
760         break;
761         // ignoring the following cases (why?)
762       case VT_SHORT:
763       case VT_FLOAT:
764       case VT_HRTIME:
765       case VT_LABEL:
766       case VT_ADDRESS:
767       case VT_OFFSET:
768         break;
769       }
770   }
771   return mark;
772 }
773
774 void
775 Hist_data::set_threshold (double proportion)
776 {
777   int index;
778   Metric *mitem;
779   Vec_loop (Metric*, metrics->get_items (), index, mitem)
780   {
781     TValue *thresh = &threshold->value[index];
782     TValue *mtotal = &total->value[index];
783     thresh->tag = mitem->get_vtype ();
784
785     if (mitem->get_subtype () == Metric::STATIC)
786       continue;
787     switch (thresh->tag)
788       {
789       case VT_INT:
790         thresh->i = (int) (proportion * (double) mtotal->i);
791         break;
792       case VT_DOUBLE:
793         thresh->d = proportion * mtotal->d;
794         break;
795       case VT_LLONG:
796       case VT_ULLONG:
797         thresh->ull = (unsigned long long) (proportion * (double) mtotal->ll);
798         break;
799       case VT_SHORT:
800       case VT_FLOAT:
801       case VT_HRTIME:
802       case VT_LABEL:
803       case VT_ADDRESS:
804       case VT_OFFSET:
805         break;
806       }
807   }
808 }
809
810 double
811 Hist_data::get_percentage (double value, int mindex)
812 {
813   double total_value;
814   if (value == 0.0)
815     return 0.0;
816
817   // Get the total value of this sample set.
818   // The value must be greater than 0.
819   total_value = total->value[mindex].to_double ();
820
821   // Find out what percentage of the total value this item is.
822   // Make sure we don't divide by zero.
823   if (total_value == 0.0)
824     return 0.0;
825   return value / total_value;
826 }
827
828 int
829 Hist_data::print_label (FILE *out_file, Metric::HistMetric *hist_metric,
830                         int space)
831 {
832   int name_offset = 0;
833   StringBuilder sb, sb1, sb2, sb3;
834   if (space > 0)
835     {
836       char *fmt = NTXT ("%*s");
837       sb.appendf (fmt, space, NTXT (""));
838       sb1.appendf (fmt, space, NTXT (""));
839       sb2.appendf (fmt, space, NTXT (""));
840       sb3.appendf (fmt, space, NTXT (""));
841     }
842   for (int i = 0; i < nmetrics; i++)
843     {
844       Metric *m = metrics->get (i);
845       Metric::HistMetric *hm = &hist_metric[i];
846       int len = hm->width;
847       char *fmt = NTXT ("%-*s");
848       if ((i > 0) && (m->get_type () == Metric::ONAME))
849         {
850           name_offset = sb1.length ();
851           fmt = NTXT (" %-*s");
852           len--;
853         }
854       sb.appendf (fmt, len, m->legend ? m->legend : NTXT (""));
855       sb1.appendf (fmt, len, hm->legend1);
856       sb2.appendf (fmt, len, hm->legend2);
857       sb3.appendf (fmt, len, hm->legend3);
858     }
859   sb.trim ();
860   if (sb.length () != 0)
861     {
862       sb.toFileLn (out_file);
863     }
864   sb1.toFileLn (out_file);
865   sb2.toFileLn (out_file);
866   sb3.toFileLn (out_file);
867   return name_offset;
868 }
869
870 void
871 Hist_data::print_content (FILE *out_file, Metric::HistMetric *hist_metric, int limit)
872 {
873   StringBuilder sb;
874   int cnt = VecSize (hist_items);
875   if (cnt > limit && limit > 0)
876     cnt = limit;
877   for (int i = 0; i < cnt; i++)
878     {
879       sb.setLength (0);
880       print_row (&sb, i, hist_metric, NTXT (" "));
881       sb.toFileLn (out_file);
882     }
883 }
884
885 static void
886 append_str (StringBuilder *sb, char *s, size_t len, int vis_bits)
887 {
888   if ((vis_bits & VAL_RATIO) != 0)
889     {
890       if (*s != 'N')    // Nan
891         sb->appendf (NTXT ("x "));
892       else
893         sb->appendf (NTXT ("  "));
894       sb->appendf (NTXT ("%*s"), (int) (len - 2), s);
895     }
896   else
897     sb->appendf (NTXT ("%*s"), (int) len, s);
898 }
899
900 void
901 Hist_data::print_row (StringBuilder *sb, int row, Metric::HistMetric *hmp,
902                       const char *mark)
903 {
904   TValue res;
905   char buf[256];
906   // Print only a list of user's metrics. ( nmetrics <= mlist->size() )
907   for (long i = 0; i < nmetrics; i++)
908     {
909       // Print only a list of user's metrics.
910       Metric *m = metrics->get (i);
911       if (!m->is_any_visible ())
912         continue;
913       Metric::HistMetric *hm = hmp + i;
914       int len = sb->length ();
915       if (m->is_tvisible ())
916         {
917           TValue *v = get_value (&res, hist_metrics[i].indTimeVal, row);
918           char *s = v->to_str (buf, sizeof (buf));
919           append_str (sb, s, hm->maxtime_width, m->get_visbits ());
920         }
921       if (m->is_visible ())
922         {
923           TValue *v = get_value (&res, i, row);
924           char *s = v->to_str (buf, sizeof (buf));
925           if (m->get_type () == BaseMetric::ONAME)
926             {
927               sb->append (mark);
928               if (i + 1 == nmetrics)
929                 sb->appendf (NTXT ("%s"), s);
930               else
931                 sb->appendf (NTXT ("%-*s "), (int) hm->maxvalue_width, s);
932               continue;
933             }
934           else
935             {
936               if (len != sb->length ())
937                 sb->append (' ');
938               append_str (sb, s, hm->maxvalue_width, m->get_visbits ());
939             }
940         }
941       if (m->is_pvisible ())
942         {
943           if (len != sb->length ())
944             sb->append (' ');
945           long met_ind = i;
946           if (m->is_tvisible () && !m->is_visible ())
947             met_ind = hist_metrics[i].indTimeVal;
948           TValue *v = get_real_value (&res, met_ind, row);
949           double percent = get_percentage (v->to_double (), met_ind);
950           if (percent == 0.0)
951             // adjust to change format from xx.yy%
952             sb->append (NTXT ("  0.  "));
953           else
954             // adjust format below to change format from xx.yy%
955             sb->appendf (NTXT ("%6.2f"), (100.0 * percent));
956         }
957       len = sb->length () - len;
958       if (hm->width > len && i + 1 != nmetrics)
959         sb->appendf (NTXT ("%*s"), (int) (hm->width - len), NTXT (" "));
960     }
961 }
962
963 TValue *
964 Hist_data::get_real_value (TValue *res, int met_index, int row)
965 {
966   HistItem *hi = hist_items->get (row);
967   Metric *m = metrics->get (met_index);
968   if (m->get_type () == BaseMetric::ONAME)
969     {
970       res->l = dbe_strdup (hi->obj->get_name ());
971       res->tag = VT_LABEL;
972       return res;
973     }
974   return hi->value + met_index;
975 }
976
977 TValue *
978 Hist_data::get_value (TValue *res, int met_index, int row)
979 {
980   HistItem *hi = hist_items->get (row);
981   Metric *m = metrics->get (met_index);
982   if ((m->get_visbits () & (VAL_DELTA | VAL_RATIO)) != 0)
983     {
984       int ind = hist_metrics[met_index].indFirstExp;
985       if ((m->get_visbits () & VAL_DELTA) != 0)
986         res->make_delta (hi->value + met_index, hi->value + ind);
987       else
988         res->make_ratio (hi->value + met_index, hi->value + ind);
989       return res;
990     }
991   return get_real_value (res, met_index, row);
992 }
993
994 TValue *
995 Hist_data::get_value (TValue *res, int met_index, HistItem *hi)
996 {
997   Metric *m = metrics->get (met_index);
998   if ((m->get_visbits () & (VAL_DELTA | VAL_RATIO)) != 0)
999     {
1000       int ind = hist_metrics[met_index].indFirstExp;
1001       if ((m->get_visbits () & VAL_DELTA) != 0)
1002         res->make_delta (hi->value + met_index, hi->value + ind);
1003       else
1004         res->make_ratio (hi->value + met_index, hi->value + ind);
1005       return res;
1006     }
1007   if (m->get_type () == BaseMetric::ONAME)
1008     {
1009       res->l = dbe_strdup (hi->obj->get_name ());
1010       res->tag = VT_LABEL;
1011       return res;
1012     }
1013   return hi->value + met_index;
1014 }
1015
1016 Metric::HistMetric *
1017 Hist_data::get_histmetrics ()
1018 {
1019   // find the width for each column.
1020   for (long i = 0, sz = metrics->size (); i < sz; i++)
1021     {
1022       Metric *m = metrics->get (i);
1023       Metric::HistMetric *hm = hist_metrics + i;
1024       if (m->is_value_visible ())
1025         {
1026           TValue res;
1027           for (long i1 = 0, sz1 = VecSize(hist_items); i1 < sz1; i1++)
1028             {
1029               TValue *v = get_value (&res, i, i1);
1030               long len = v->get_len ();
1031               if (hm->maxvalue_width < len)
1032                 hm->maxvalue_width = len;
1033             }
1034           if ((m->get_visbits () & VAL_RATIO) != 0)
1035             hm->maxvalue_width += 2; // "x "
1036         }
1037     }
1038
1039   for (long i = 0, sz = metrics->size (); i < sz; i++)
1040     {
1041       Metric *m = metrics->get (i);
1042       Metric::HistMetric *hm = hist_metrics + i;
1043       if (m->is_time_visible ())
1044         // take a value from depended metric
1045         hm->maxtime_width = hist_metrics[hm->indTimeVal].maxvalue_width;
1046       m->legend_width (hm, 2);
1047     }
1048   return hist_metrics;
1049 }
1050
1051 void
1052 Hist_data::update_total (Hist_data::HistItem *new_total)
1053 {
1054   for (long i = 0, sz = metrics->size (); i < sz; i++)
1055     total->value[i] = new_total->value[i];
1056 }
1057
1058 void
1059 Hist_data::update_max (Metric::HistMetric *hm_tmp)
1060 {
1061   Metric::HistMetric *hms = get_histmetrics ();
1062   for (int i = 0; i < nmetrics; i++)
1063     {
1064       Metric::HistMetric *hm = hms + i;
1065       Metric::HistMetric *hm1 = hm_tmp + i;
1066       if (hm1->maxtime_width < hm->maxtime_width)
1067         hm1->maxtime_width = hm->maxtime_width;
1068       if (hm1->maxvalue_width < hm->maxvalue_width)
1069         hm1->maxvalue_width = hm->maxvalue_width;
1070     }
1071 }
1072
1073 void
1074 Hist_data::update_legend_width (Metric::HistMetric *hm_tmp)
1075 {
1076   for (int i = 0; i < nmetrics; i++)
1077     {
1078       Metric *m = metrics->get (i);
1079       m->legend_width (hm_tmp + i, 2);
1080     }
1081 }
1082
1083 void
1084 Metric::HistMetric::update_max (Metric::HistMetric *hm)
1085 {
1086   if (maxtime_width < hm->maxtime_width)
1087     maxtime_width = hm->maxtime_width;
1088   if (maxvalue_width < hm->maxvalue_width)
1089     maxvalue_width = hm->maxvalue_width;
1090 }
1091
1092 void
1093 Metric::HistMetric::init ()
1094 {
1095   width = 0;
1096   maxvalue_width = 0;
1097   maxtime_width = 0;
1098   legend1[0] = 0;
1099   legend2[0] = 0;
1100   legend3[0] = 0;
1101   indFirstExp = -1;
1102   indTimeVal = -1;
1103 }
1104
1105 size_t
1106 Hist_data::value_maxlen (int mindex)
1107 {
1108   size_t maxlen = maximum->value[mindex].get_len ();
1109   size_t minlen = minimum->value[mindex].get_len ();
1110   // minlen can be bigger than maxlen only for negative value
1111   return minlen > maxlen ? minlen : maxlen;
1112 }
1113
1114 size_t
1115 Hist_data::time_len (TValue *value, int clock)
1116 {
1117   TValue tm_value;
1118   tm_value.tag = VT_DOUBLE;
1119   tm_value.sign = value->sign;
1120   tm_value.d = 1.e-6 * value->ll / clock;
1121   return tm_value.get_len ();
1122 }
1123
1124 size_t
1125 Hist_data::time_maxlen (int mindex, int clock)
1126 {
1127   size_t maxlen = time_len (&(maximum->value[mindex]), clock);
1128   size_t minlen = time_len (&(minimum->value[mindex]), clock);
1129   // minlen can be bigger than maxlen only for negative value
1130   return minlen > maxlen ? minlen : maxlen;
1131 }
1132
1133 size_t
1134 Hist_data::name_len (HistItem *item)
1135 {
1136   char *name = item->obj->get_name ();
1137   return strlen (name);
1138 }
1139
1140 size_t
1141 Hist_data::name_maxlen ()
1142 {
1143   size_t res = 0;
1144   for (long i = 0; i < size (); i++)
1145     {
1146       HistItem *hi = fetch (i);
1147       size_t len = name_len (hi);
1148       if (res < len)
1149         res = len;
1150     }
1151   return res;
1152 }
1153
1154 // Returns vector of object ids for the vector of selections
1155 //      returns NULL if no valid selections
1156 Vector<uint64_t> *
1157 Hist_data::get_object_indices (Vector<int> *selections)
1158 {
1159   // if no selections, return NULL
1160   if (selections == NULL || selections->size () == 0)
1161     return NULL;
1162
1163   Vector<uint64_t> *indices = new Vector<uint64_t>;
1164   for (long i = 0, sz = selections->size (); i < sz; i++)
1165     {
1166       int sel = selections->get (i);
1167       HistItem *hi = hist_items->get (sel);
1168       if (hi == NULL || hi->obj == NULL)
1169         continue;
1170       Vector<Histable*> *v = hi->obj->get_comparable_objs ();
1171       for (long i1 = 0, sz1 = v ? v->size () : 0; i1 < sz1; i1++)
1172         {
1173           Histable *h1 = v->get (i1);
1174           if (h1 && (indices->find_r (h1->id) < 0))
1175             indices->append (h1->id);
1176         }
1177       if (indices->find_r (hi->obj->id) < 0)
1178         indices->append (hi->obj->id);
1179     }
1180   return indices;
1181 }
1182
1183 DbeInstr::DbeInstr (uint64_t _id, int _flags, Function *_func, uint64_t _addr)
1184 {
1185   id = _id;
1186   flags = _flags;
1187   addr = _addr;
1188   func = _func;
1189   img_offset = addr + func->img_offset;
1190   lineno = -1;
1191   size = 0;
1192   current_name_format = NA;
1193   isUsed = false;
1194   inlinedInd = -1;
1195 }
1196
1197 int
1198 DbeInstr::pc_cmp (DbeInstr *instr2)
1199 {
1200   int result = 0;
1201   if (instr2 == NULL)
1202     return -1;
1203
1204   // All PC's with the Line flag go to the
1205   // end of the list. See Module::init_index()
1206   if (flags & PCLineFlag)
1207     {
1208       if (instr2->flags & PCLineFlag)
1209         {
1210           if (addr < instr2->addr)
1211             result = -1;
1212           else if (addr > instr2->addr)
1213             result = 1;
1214           else
1215             result = 0;
1216         }
1217       else
1218         result = 1;
1219     }
1220   else if (instr2->flags & PCLineFlag)
1221     result = -1;
1222   else if (func == instr2->func)
1223     {
1224       if (size == 0)
1225         {
1226           if (addr < instr2->addr)
1227             result = -1;
1228           else if (addr == instr2->addr)
1229             result = 0;
1230           else if (addr >= instr2->addr + instr2->size)
1231             result = 1;
1232           else
1233             result = 0;
1234         }
1235       else if (instr2->size == 0)
1236         {
1237           if (addr > instr2->addr)
1238             result = 1;
1239           else if (addr + size <= instr2->addr)
1240             result = -1;
1241           else
1242             result = 0;
1243         }
1244       else if (addr < instr2->addr)
1245         result = -1;
1246       else if (addr > instr2->addr)
1247         result = 1;
1248       else
1249         result = 0;
1250
1251       if (result == 0)
1252         {
1253           if (flags & PCTrgtFlag)
1254             {
1255               if (!(instr2->flags & PCTrgtFlag))
1256                 result = -1;
1257             }
1258           else if (instr2->flags & PCTrgtFlag)
1259             result = 1;
1260         }
1261     }
1262   else
1263     result = func->func_cmp (instr2->func);
1264   return result;
1265 }
1266
1267 char *
1268 DbeInstr::get_name (NameFormat nfmt)
1269 {
1270   if (name && (nfmt == current_name_format || nfmt == Histable::NA))
1271     return name;
1272
1273   free (name);
1274   name = NULL;
1275   current_name_format = nfmt;
1276   char *fname = func->get_name (nfmt);
1277
1278   if (func->flags & FUNC_FLAG_NO_OFFSET)
1279     name = dbe_strdup (fname);
1280   else if (addr == (uint64_t) - 1
1281            && func != dbeSession->get_JUnknown_Function ())
1282     // We use three heuristics above to recognize this special case.
1283     // Once the original problem with bci == -1 is fixed, we don't
1284     // need it any more.
1285     name = dbe_sprintf (GTXT ("<Function %s: HotSpot-compiled leaf instructions>"),
1286                         fname);
1287   else if (addr == (uint64_t) - 3)
1288     name = dbe_sprintf (GTXT ("%s <Java native method>"), fname);
1289   else
1290     {
1291       char buf[64], *typetag = NTXT (""), *alloc_typetag = NULL;
1292       StringBuilder sb;
1293       sb.append (fname);
1294       if (func != dbeSession->get_JUnknown_Function ())
1295         {
1296           if (addr <= 0xFFFFFFFFU)
1297             snprintf (buf, sizeof (buf), " + 0x%08X", (unsigned int) addr);
1298           else
1299             snprintf (buf, sizeof (buf), " + 0x%016llX",
1300                       (unsigned long long) addr);
1301         }
1302       else
1303         {
1304           char *subname;
1305           switch ((long int) addr)
1306             {
1307             case -1:
1308               subname = GTXT ("agent error");
1309               break;
1310             case -2:
1311               subname = GTXT ("GC active");
1312               break;
1313             case -3:
1314               subname = GTXT ("unknown non-Java frame");
1315               break;
1316             case -4:
1317               subname = GTXT ("unwalkable non-Java frame");
1318               break;
1319             case -5:
1320               subname = GTXT ("unknown Java frame");
1321               break;
1322             case -6:
1323               subname = GTXT ("unwalkable Java frame");
1324               break;
1325             case -7:
1326               subname = GTXT ("unknown thread state");
1327               break;
1328             case -8:
1329               subname = GTXT ("thread in exit");
1330               break;
1331             case -9:
1332               subname = GTXT ("deopt in process ticks");
1333               break;
1334             case -10:
1335               subname = GTXT ("safepoint synchronizing ticks");
1336               break;
1337             default:
1338               subname = GTXT ("unexpected error");
1339               break;
1340             }
1341           snprintf (buf, sizeof (buf), "<%s (%d)>", subname, (int) addr);
1342         }
1343       sb.append (buf);
1344       if (flags & PCTrgtFlag)
1345         // annotate synthetic instruction
1346         sb.append ('*'); // special distinguishing marker
1347
1348       DbeLine *dbeline = mapPCtoLine (NULL);
1349       char *str = NULL;
1350       if (dbeline && dbeline->lineno > 0)
1351         str = strrchr (dbeline->get_name (nfmt), ',');
1352       if (str)
1353         sb.append (str);
1354       if (strlen (typetag) > 0)
1355         { // include padding for alignment
1356           do
1357             {
1358               sb.append (' ');
1359             }
1360           while (sb.length () < 40);
1361           sb.append (typetag);
1362           delete alloc_typetag;
1363         }
1364       if (inlinedInd >= 0)
1365         add_inlined_info (&sb);
1366       name = sb.toString ();
1367     }
1368   return name;
1369 }
1370
1371 DbeLine*
1372 DbeInstr::mapPCtoLine (SourceFile *sf)
1373 {
1374   if (inlinedInd == -1)
1375     {
1376       inlinedInd = -2;
1377       for (int i = 0; i < func->inlinedSubrCnt; i++)
1378         {
1379           InlinedSubr *p = func->inlinedSubr + i;
1380           if (p->level == 0)
1381             {
1382               if (addr < p->low_pc)
1383                 break;
1384               if (p->contains (addr))
1385                 {
1386                   inlinedInd = i;
1387                   break;
1388                 }
1389             }
1390         }
1391     }
1392   if (inlinedInd >= 0)
1393     {
1394       DbeLine *dl = func->inlinedSubr[inlinedInd].dbeLine;
1395       return dl->sourceFile->find_dbeline (func, dl->lineno);
1396     }
1397   return func->mapPCtoLine (addr, sf);
1398 }
1399
1400 void
1401 DbeInstr::add_inlined_info (StringBuilder *sb)
1402 {
1403   do
1404     {
1405       sb->append (' ');
1406     }
1407   while (sb->length () < 40);
1408   sb->append (NTXT ("<-- "));
1409
1410   InlinedSubr *last = NULL;
1411   for (int i = inlinedInd; i < func->inlinedSubrCnt; i++)
1412     {
1413       InlinedSubr *p = func->inlinedSubr + i;
1414       if (p->level == 0 && i > inlinedInd)
1415         break;
1416       if (!p->contains (addr))
1417         continue;
1418       if (last)
1419         {
1420           if (last->fname)
1421             {
1422               sb->append (last->fname);
1423               sb->append (' ');
1424             }
1425           DbeLine *dl = p->dbeLine;
1426           sb->appendf (NTXT ("%s:%lld <-- "), get_basename (dl->sourceFile->get_name ()), (long long) dl->lineno);
1427         }
1428       last = p;
1429     }
1430   if (last)
1431     {
1432       if (last->fname)
1433         {
1434           sb->append (last->fname);
1435           sb->append (' ');
1436         }
1437     }
1438   DbeLine *dl = func->mapPCtoLine (addr, NULL);
1439   sb->appendf ("%s:%lld ", get_basename (dl->sourceFile->get_name ()),
1440                (long long) dl->lineno);
1441 }
1442
1443 char *
1444 DbeInstr::get_descriptor ()
1445 {
1446   char *typetag = NTXT ("");
1447   if ((flags & PCTrgtFlag) == 0)  // not synthetic instruction
1448     { // use memop descriptor, if available
1449       Module *mod = func->module;
1450       if (mod->hwcprof  && mod->infoList)
1451         {
1452           long i;
1453           inst_info_t *info = NULL;
1454           Vec_loop (inst_info_t*, mod->infoList, i, info)
1455           {
1456             if (info->offset == func->img_offset + addr) break;
1457           }
1458           if (info)
1459             {
1460               long t;
1461               datatype_t *dtype = NULL;
1462               Vec_loop (datatype_t*, mod->datatypes, t, dtype)
1463               {
1464                 if (dtype->datatype_id == info->memop->datatype_id)
1465                   break;
1466               }
1467               if (dtype && dtype->dobj)
1468                 typetag = dtype->dobj->get_name ();
1469             }
1470         }
1471     }
1472   return dbe_strdup (typetag);
1473 }
1474
1475 int64_t
1476 DbeInstr::get_size ()
1477 {
1478   //    Function *func = (Function*)dbeSession->get_hobj( pc );
1479   //    Module   *mod  = func ? func->module : NULL;
1480   //    return mod ? mod->instrSize( func->img_offset + addr ) : 0;
1481   return size;
1482 }
1483
1484 uint64_t
1485 DbeInstr::get_addr ()
1486 {
1487   return func->get_addr () + addr;
1488 }
1489
1490 Histable *
1491 DbeInstr::convertto (Type type, Histable *obj)
1492 {
1493   Histable *res = NULL;
1494   SourceFile *source = (SourceFile*) obj;
1495   switch (type)
1496     {
1497     case INSTR:
1498       res = this;
1499       break;
1500     case LINE:
1501       res = mapPCtoLine (source);
1502       break;
1503     case SOURCEFILE:
1504       res = mapPCtoLine (source);
1505       if (res)
1506         res = ((DbeLine*) res)->sourceFile;
1507       break;
1508     case FUNCTION:
1509       res = func;
1510       break;
1511     default:
1512       assert (0);
1513     }
1514   return res;
1515 }
1516
1517 char *
1518 DbeEA::get_name (NameFormat)
1519 {
1520   if (name == NULL)
1521     // generate one
1522     name = dbe_strdup (dbeSession->localized_SP_UNKNOWN_NAME);
1523   return name;
1524 }
1525
1526 Histable *
1527 DbeEA::convertto (Type type, Histable *obj)
1528 {
1529   Histable *res = NULL;
1530   assert (obj == NULL);
1531   switch (type)
1532     {
1533     case EADDR:
1534       res = this;
1535       break;
1536     case DOBJECT:
1537       res = dobj;
1538       break;
1539     default:
1540       assert (0);
1541     }
1542   return res;
1543 }
1544
1545 DbeLine::DbeLine (Function *_func, SourceFile *sf, int _lineno)
1546 {
1547   func = _func;
1548   lineno = _lineno;
1549   sourceFile = sf;
1550   id = sf->id + _lineno;
1551   offset = 0;
1552   size = 0;
1553   flags = 0;
1554   include = NULL;
1555   dbeline_func_next = NULL;
1556   dbeline_base = this;
1557   current_name_format = Histable::NA;
1558 }
1559
1560 DbeLine::~DbeLine ()
1561 {
1562   delete dbeline_func_next;
1563 }
1564
1565 int
1566 DbeLine::line_cmp (DbeLine *dbl)
1567 {
1568   return lineno - dbl->lineno;
1569 }
1570
1571 void
1572 DbeLine::init_Offset (uint64_t p_offset)
1573 {
1574   if (offset == 0)
1575     offset = p_offset;
1576   if (dbeline_base && dbeline_base->offset == 0)
1577     dbeline_base->offset = p_offset;
1578 }
1579
1580 char *
1581 DbeLine::get_name (NameFormat nfmt)
1582 {
1583   char *srcname = NULL, *basename, *fname;
1584
1585   if (func == NULL)
1586     {
1587       if (name)
1588         return name;
1589       srcname = sourceFile->get_name ();
1590       basename = get_basename (srcname);
1591       name = dbe_sprintf (GTXT ("line %u in \"%s\""), lineno, basename);
1592       return name;
1593     }
1594
1595   if (name && (nfmt == current_name_format || nfmt == Histable::NA))
1596     return name;
1597
1598   current_name_format = nfmt;
1599   free (name);
1600   fname = func->get_name (nfmt);
1601   if (func->flags & (FUNC_FLAG_SIMULATED | FUNC_FLAG_NO_OFFSET))
1602     {
1603       name = dbe_strdup (fname);
1604       return name;
1605     }
1606
1607   if (sourceFile)
1608     srcname = sourceFile->get_name ();
1609   if (!srcname || strlen (srcname) == 0)
1610     srcname = func->getDefSrcName ();
1611   basename = get_basename (srcname);
1612
1613   if (lineno != 0)
1614     {
1615       if (sourceFile == func->getDefSrc ())
1616         name = dbe_sprintf (GTXT ("%s, line %u in \"%s\""), fname, lineno,
1617                             basename);
1618       else
1619         name = dbe_sprintf (GTXT ("%s, line %u in alternate source context \"%s\""),
1620                             fname, lineno, basename);
1621     }
1622   else if (sourceFile == NULL || (sourceFile->flags & SOURCE_FLAG_UNKNOWN) != 0)
1623     name = dbe_sprintf (GTXT ("<Function: %s, instructions without line numbers>"),
1624                         fname);
1625   else
1626     name = dbe_sprintf (GTXT ("<Function: %s, instructions from source file %s>"),
1627                           fname, basename);
1628   return name;
1629 }
1630
1631 int64_t
1632 DbeLine::get_size ()
1633 {
1634   return size;
1635 }
1636
1637 uint64_t
1638 DbeLine::get_addr ()
1639 {
1640   if (func == NULL && dbeline_func_next == NULL)
1641     return (uint64_t) 0;
1642   Function *f = func ? func : dbeline_func_next->func;
1643   return f->get_addr () + offset;
1644 }
1645
1646 Histable *
1647 DbeLine::convertto (Type type, Histable *obj)
1648 {
1649   Histable *res = NULL;
1650   switch (type)
1651     {
1652     case INSTR:
1653       {
1654         Function *f = (Function *) convertto (FUNCTION, NULL);
1655         if (f)
1656           res = f->find_dbeinstr (0, offset);
1657         break;
1658       }
1659     case LINE:
1660       res = dbeline_base;
1661       break;
1662     case FUNCTION:
1663       if (func)
1664         {
1665           res = func;
1666           break;
1667         }
1668       else
1669         {
1670           int not_found = 1;
1671           for (DbeLine *dl = dbeline_base; dl; dl = dl->dbeline_func_next)
1672             {
1673               Function *f = dl->func;
1674               not_found = (obj == NULL // XXXX pass dbeview as Histable*
1675                            || ((DbeView*) obj)->get_path_tree ()->get_func_nodeidx (f) == 0);
1676               if (f && f->def_source == sourceFile && (!not_found))
1677                 {
1678                   res = f;
1679                   break;
1680                 }
1681             }
1682           if (res == NULL && dbeline_func_next)
1683             {
1684               for (DbeLine *dl = dbeline_base; dl; dl = dl->dbeline_func_next)
1685                 {
1686                   Function *f = dl->func;
1687                   if (f && f->def_source == sourceFile)
1688                     {
1689                       res = f;
1690                       break;
1691                     }
1692                 }
1693             }
1694           if (res == NULL && dbeline_func_next)
1695             res = dbeline_func_next->func;
1696         }
1697       break;
1698     case SOURCEFILE:
1699       res = (include) ? include : sourceFile;
1700       break;
1701     default:
1702       assert (0);
1703     }
1704   return res;
1705 }
1706
1707 CStack_data::CStack_data (MetricList *_metrics)
1708 {
1709   metrics = _metrics;
1710   total = new_cstack_item ();
1711   cstack_items = new Vector<CStack_item*>;
1712 }
1713
1714 CStack_data::CStack_item::CStack_item (long n)
1715 {
1716   stack = NULL;
1717   count = 0;
1718   val = 0;
1719   value = new TValue[n];
1720   memset (value, 0, sizeof (TValue) * n);
1721 }
1722
1723 CStack_data::CStack_item::~CStack_item ()
1724 {
1725   delete stack;
1726   delete[] value;
1727 }
1728
1729 CStack_data::CStack_item *
1730 CStack_data::new_cstack_item ()
1731 {
1732   int nmetrics = metrics->get_items ()->size ();
1733   CStack_item *item = new CStack_item (nmetrics);
1734
1735   // We precalculate all metrics as integer values
1736   // and convert them to appropriate types later.
1737   for (int i = 0; i < nmetrics; i++)
1738     item->value[i].tag = metrics->get_items ()->fetch (i)->get_vtype ();
1739   return item;
1740 }
1741
1742 HistableFile::HistableFile ()
1743 {
1744   dbeFile = NULL;
1745   isUsed = false;
1746 }
1747
1748 Histable::Histable ()
1749 {
1750   name = NULL;
1751   id = 0;
1752   comparable_objs = NULL;
1753   phaseCompareIdx = -1;
1754 }
1755
1756 Histable::~Histable ()
1757 {
1758   delete_comparable_objs ();
1759   free (name);
1760 }
1761
1762 void
1763 Histable::delete_comparable_objs ()
1764 {
1765   if (comparable_objs)
1766     {
1767       Vector<Histable*> *v = comparable_objs;
1768       for (int i = 0; i < v->size (); i++)
1769         {
1770           Histable *h = v->fetch (i);
1771           if (h)
1772             {
1773               h->comparable_objs = NULL;
1774               h->phaseCompareIdx = phaseCompareIdx;
1775             }
1776         }
1777       delete v;
1778     }
1779 }
1780
1781 void
1782 Histable::update_comparable_objs ()
1783 {
1784   if (phaseCompareIdx != ExpGroup::phaseCompareIdx)
1785     {
1786       phaseCompareIdx = ExpGroup::phaseCompareIdx;
1787       delete_comparable_objs ();
1788     }
1789 }
1790
1791 Vector<Histable*> *
1792 Histable::get_comparable_objs ()
1793 {
1794   return comparable_objs;
1795 }
1796
1797 Histable *
1798 Histable::get_compare_obj ()
1799 {
1800   Vector<Histable*> *v = get_comparable_objs ();
1801   for (long i = 0, sz = VecSize (v); i < sz; i++)
1802     {
1803       Histable *h = v->get (i);
1804       if (h)
1805         return h;
1806     }
1807   return this;
1808 }
1809
1810 #define CASE_S(x)   case x: return (char *) #x
1811
1812 char *
1813 Histable::type_to_string ()
1814 {
1815   switch (get_type ())
1816     {
1817       CASE_S (INSTR);
1818       CASE_S (LINE);
1819       CASE_S (FUNCTION);
1820       CASE_S (MODULE);
1821       CASE_S (LOADOBJECT);
1822       CASE_S (EADDR);
1823       CASE_S (MEMOBJ);
1824       CASE_S (INDEXOBJ);
1825       CASE_S (PAGE);
1826       CASE_S (DOBJECT);
1827       CASE_S (SOURCEFILE);
1828       CASE_S (EXPERIMENT);
1829       CASE_S (OTHER);
1830     default:
1831       break;
1832     }
1833   return NTXT ("ERROR");
1834 }
1835
1836 void
1837 Histable::dump_comparable_objs ()
1838 {
1839   Dprintf (DEBUG_COMPARISON,
1840            "# Histable::dump_comparable_objs type=%s(%d) 0x%lx id=%lld %s\n",
1841            type_to_string (), get_type (), (unsigned long) this, (long long) id,
1842            STR (get_name ()));
1843   for (int i = 0, sz = comparable_objs ? comparable_objs->size () : 0; i < sz; i++)
1844     {
1845       Histable *h = comparable_objs->fetch (i);
1846       Dprintf (DEBUG_COMPARISON, "  %d type=%s(%d) 0x%lx id=%lld %s\n", i,
1847                h ? h->type_to_string () : "", h ? h->get_type () : -1,
1848                (unsigned long) h, (long long) (h ? h->id : 0),
1849                h ? STR (h->get_name ()) : NTXT (""));
1850     }
1851 }
1852
1853 char *
1854 Histable::dump ()
1855 {
1856   StringBuilder sb;
1857   sb.appendf (sizeof (long) == 32
1858               ? " 0x%08lx : type=%s(%d) id=%lld %s"
1859               : " 0x%016lx : type=%s(%d) id=%lld %s",
1860               (unsigned long) this, type_to_string (), get_type (),
1861               (long long) id, STR (get_name ()));
1862   switch (get_type ())
1863     {
1864     case INSTR:
1865       {
1866         DbeInstr *o = (DbeInstr *) this;
1867         sb.appendf (sizeof (long) == 32
1868                     ? "   func=0x%08lx lineno=%lld"
1869                     : "   func=0x%016lx lineno=%lld",
1870                     (unsigned long) o->func, (long long) o->lineno);
1871         break;
1872       }
1873     case LINE:
1874       {
1875         DbeLine *o = (DbeLine *) this;
1876         sb.appendf (sizeof (long) == 32
1877                     ? "   func=0x%08lx sourceFile=0x%08lx lineno=%lld"
1878                     : "   func=0x%016lx sourceFile=0x%016lx lineno=%lld",
1879                     (unsigned long) o->func, (unsigned long) o->sourceFile,
1880                     (long long) o->lineno);
1881         break;
1882       }
1883     default:
1884       break;
1885     }
1886   return sb.toString ();
1887 }
This page took 0.128845 seconds and 4 git commands to generate.